mirror of https://github.com/tasks/tasks
Reminder test improvements
Alex Baker
9 years ago
parent
c02164ad7a
commit
f46aebb784
@ -1,71 +0,0 @@
|
||||
package com.todoroo.astrid.reminders;
|
||||
|
||||
import android.support.test.runner.AndroidJUnit4;
|
||||
|
||||
import com.todoroo.astrid.data.Task;
|
||||
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.tasks.preferences.Preferences;
|
||||
import org.tasks.time.DateTime;
|
||||
|
||||
import static android.support.test.InstrumentationRegistry.getTargetContext;
|
||||
import static com.natpryce.makeiteasy.MakeItEasy.with;
|
||||
import static com.todoroo.astrid.data.Task.NOTIFY_AT_DEADLINE;
|
||||
import static com.todoroo.astrid.reminders.ReminderService.NO_ALARM;
|
||||
import static junit.framework.Assert.assertEquals;
|
||||
import static org.tasks.makers.TaskMaker.DUE_DATE;
|
||||
import static org.tasks.makers.TaskMaker.DUE_TIME;
|
||||
import static org.tasks.makers.TaskMaker.REMINDERS;
|
||||
import static org.tasks.makers.TaskMaker.REMINDER_LAST;
|
||||
import static org.tasks.makers.TaskMaker.newTask;
|
||||
|
||||
@RunWith(AndroidJUnit4.class)
|
||||
public class NotifyAtDeadlineTest {
|
||||
|
||||
private ReminderService reminderService;
|
||||
|
||||
@Before
|
||||
public void setUp() {
|
||||
Preferences preferences = new Preferences(getTargetContext(), null);
|
||||
reminderService = new ReminderService(preferences, null);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoReminderWhenNoDueDate() {
|
||||
Task task = newTask(with(REMINDERS, NOTIFY_AT_DEADLINE));
|
||||
assertEquals(NO_ALARM, reminderService.calculateNextDueDateReminder(task));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoReminderWhenNotifyAtDeadlineFlagNotSet() {
|
||||
Task task = newTask(with(DUE_TIME, new DateTime(2014, 1, 24, 19, 23)));
|
||||
assertEquals(NO_ALARM, reminderService.calculateNextDueDateReminder(task));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testScheduleReminderAtDueTime() {
|
||||
final DateTime dueDate = new DateTime(2014, 1, 24, 19, 23);
|
||||
Task task = newTask(with(DUE_TIME, dueDate), with(REMINDERS, NOTIFY_AT_DEADLINE));
|
||||
assertEquals(dueDate.plusSeconds(1).getMillis(), reminderService.calculateNextDueDateReminder(task));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testScheduleReminderAtDefaultDueTime() {
|
||||
final DateTime dueDate = new DateTime(2015, 12, 29, 12, 0);
|
||||
Task task = newTask(with(DUE_DATE, dueDate), with(REMINDERS, NOTIFY_AT_DEADLINE));
|
||||
assertEquals(dueDate.withHourOfDay(18).getMillis(),
|
||||
reminderService.calculateNextDueDateReminder(task));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoReminderIfAlreadyRemindedPastDueDate() {
|
||||
final DateTime dueDate = new DateTime(2015, 12, 29, 19, 23);
|
||||
Task task = newTask(
|
||||
with(DUE_TIME, dueDate),
|
||||
with(REMINDER_LAST, dueDate.plusSeconds(1)),
|
||||
with(REMINDERS, NOTIFY_AT_DEADLINE));
|
||||
assertEquals(NO_ALARM, reminderService.calculateNextDueDateReminder(task));
|
||||
}
|
||||
}
|
||||
@ -1,139 +0,0 @@
|
||||
package com.todoroo.astrid.reminders;
|
||||
|
||||
import android.support.test.runner.AndroidJUnit4;
|
||||
|
||||
import org.junit.After;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.InOrder;
|
||||
import org.tasks.Freeze;
|
||||
import org.tasks.Snippet;
|
||||
import org.tasks.jobs.JobManager;
|
||||
import org.tasks.jobs.Reminder;
|
||||
import org.tasks.makers.TaskMaker;
|
||||
import org.tasks.preferences.Preferences;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
||||
import static com.natpryce.makeiteasy.MakeItEasy.with;
|
||||
import static com.todoroo.astrid.reminders.ReminderService.TYPE_DUE;
|
||||
import static java.util.Arrays.asList;
|
||||
import static java.util.Collections.singletonList;
|
||||
import static junit.framework.Assert.assertEquals;
|
||||
import static org.mockito.AdditionalAnswers.returnsFirstArg;
|
||||
import static org.mockito.Matchers.anyLong;
|
||||
import static org.mockito.Mockito.inOrder;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.Mockito.verifyNoMoreInteractions;
|
||||
import static org.mockito.Mockito.when;
|
||||
import static org.tasks.makers.TaskMaker.newTask;
|
||||
import static org.tasks.time.DateTimeUtils.currentTimeMillis;
|
||||
|
||||
@RunWith(AndroidJUnit4.class)
|
||||
public class ReminderAlarmSchedulerTest {
|
||||
|
||||
private static final long ONE_MINUTE = TimeUnit.MINUTES.toMillis(1);
|
||||
|
||||
private JobManager jobManager;
|
||||
private ReminderAlarmScheduler scheduler;
|
||||
|
||||
@Before
|
||||
public void before() {
|
||||
jobManager = mock(JobManager.class);
|
||||
Preferences preferences = mock(Preferences.class);
|
||||
when(preferences.adjustForQuietHours(anyLong())).then(returnsFirstArg());
|
||||
scheduler = new ReminderAlarmScheduler(jobManager, preferences);
|
||||
}
|
||||
|
||||
@After
|
||||
public void after() {
|
||||
verifyNoMoreInteractions(jobManager);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void scheduleFirstReminder() {
|
||||
long now = currentTimeMillis();
|
||||
|
||||
scheduler.createAlarm(newTask(with(TaskMaker.ID, 1L)), now, 0);
|
||||
|
||||
verify(jobManager).scheduleReminder(now, true);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void dontScheduleLaterReminder() {
|
||||
long now = currentTimeMillis();
|
||||
|
||||
scheduler.createAlarm(newTask(with(TaskMaker.ID, 1L)), now, 0);
|
||||
scheduler.createAlarm(newTask(with(TaskMaker.ID, 1L)), now + ONE_MINUTE, 0);
|
||||
|
||||
verify(jobManager).scheduleReminder(now, true);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void rescheduleNewerReminder() {
|
||||
long now = currentTimeMillis();
|
||||
|
||||
scheduler.createAlarm(newTask(with(TaskMaker.ID, 1L)), now, 0);
|
||||
scheduler.createAlarm(newTask(with(TaskMaker.ID, 2L)), now - ONE_MINUTE, 0);
|
||||
|
||||
InOrder order = inOrder(jobManager);
|
||||
order.verify(jobManager).scheduleReminder(now, true);
|
||||
order.verify(jobManager).scheduleReminder(now - ONE_MINUTE, true);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void removeLastReminderCancelsJob() {
|
||||
long now = currentTimeMillis();
|
||||
scheduler.createAlarm(newTask(with(TaskMaker.ID, 1L)), now, 0);
|
||||
|
||||
scheduler.createAlarm(newTask(with(TaskMaker.ID, 1L)), 0, 0);
|
||||
|
||||
InOrder order = inOrder(jobManager);
|
||||
order.verify(jobManager).scheduleReminder(now, true);
|
||||
order.verify(jobManager).cancelReminders();
|
||||
}
|
||||
|
||||
@Test
|
||||
public void removePastRemindersReturnsPastReminder() {
|
||||
long now = currentTimeMillis();
|
||||
|
||||
Freeze.freezeAt(now).thawAfter(new Snippet() {{
|
||||
scheduler.createAlarm(newTask(with(TaskMaker.ID, 1L)), now, TYPE_DUE);
|
||||
|
||||
List<Reminder> reminders = scheduler.removePastReminders();
|
||||
|
||||
verify(jobManager).scheduleReminder(now, true);
|
||||
|
||||
assertEquals(singletonList(new Reminder(1, now, TYPE_DUE)), reminders);
|
||||
}});
|
||||
}
|
||||
|
||||
@Test
|
||||
public void dontRescheduleForSecondJobAtSameTime() {
|
||||
long now = currentTimeMillis();
|
||||
|
||||
scheduler.createAlarm(newTask(with(TaskMaker.ID, 1L)), now, TYPE_DUE);
|
||||
scheduler.createAlarm(newTask(with(TaskMaker.ID, 2L)), now, TYPE_DUE);
|
||||
|
||||
verify(jobManager).scheduleReminder(now, true);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void removePastRemindersReturnsPastRemindersAtSameTime() {
|
||||
long now = currentTimeMillis();
|
||||
|
||||
Freeze.freezeAt(now).thawAfter(new Snippet() {{
|
||||
scheduler.createAlarm(newTask(with(TaskMaker.ID, 1L)), now, TYPE_DUE);
|
||||
scheduler.createAlarm(newTask(with(TaskMaker.ID, 2L)), now, TYPE_DUE);
|
||||
|
||||
List<Reminder> reminders = scheduler.removePastReminders();
|
||||
|
||||
verify(jobManager).scheduleReminder(now, true);
|
||||
|
||||
assertEquals(asList(new Reminder(1, now, TYPE_DUE), new Reminder(2, now, TYPE_DUE)), reminders);
|
||||
}});
|
||||
}
|
||||
}
|
||||
@ -1,277 +1,315 @@
|
||||
/**
|
||||
* Copyright (c) 2012 Todoroo Inc
|
||||
*
|
||||
* See the file "LICENSE" for the full license governing this code.
|
||||
*/
|
||||
package com.todoroo.astrid.reminders;
|
||||
|
||||
import android.support.test.runner.AndroidJUnit4;
|
||||
|
||||
import com.todoroo.andlib.utility.DateUtilities;
|
||||
import com.todoroo.astrid.dao.TaskDao;
|
||||
import com.todoroo.astrid.data.Task;
|
||||
|
||||
import org.junit.After;
|
||||
import org.junit.Before;
|
||||
import org.junit.Test;
|
||||
import org.junit.runner.RunWith;
|
||||
import org.mockito.ArgumentCaptor;
|
||||
import org.mockito.InOrder;
|
||||
import org.tasks.Snippet;
|
||||
import org.tasks.injection.InjectingTestCase;
|
||||
import org.tasks.injection.TestComponent;
|
||||
import org.tasks.jobs.JobQueue;
|
||||
import org.tasks.jobs.Reminder;
|
||||
import org.tasks.preferences.Preferences;
|
||||
import org.tasks.time.DateTime;
|
||||
|
||||
import java.util.concurrent.TimeUnit;
|
||||
|
||||
import javax.inject.Inject;
|
||||
|
||||
import static com.natpryce.makeiteasy.MakeItEasy.with;
|
||||
import static com.todoroo.astrid.data.Task.NOTIFY_AFTER_DEADLINE;
|
||||
import static com.todoroo.astrid.data.Task.NOTIFY_AT_DEADLINE;
|
||||
import static com.todoroo.astrid.reminders.ReminderService.TYPE_RANDOM;
|
||||
import static junit.framework.Assert.assertEquals;
|
||||
import static junit.framework.Assert.assertTrue;
|
||||
import static junit.framework.Assert.fail;
|
||||
import static org.mockito.Mockito.inOrder;
|
||||
import static org.mockito.Mockito.mock;
|
||||
import static org.mockito.Mockito.verify;
|
||||
import static org.mockito.Mockito.verifyNoMoreInteractions;
|
||||
import static org.tasks.Freeze.freezeClock;
|
||||
import static org.tasks.Freeze.thaw;
|
||||
import static org.tasks.date.DateTimeUtils.newDateTime;
|
||||
import static org.tasks.makers.TaskMaker.COMPLETION_TIME;
|
||||
import static org.tasks.makers.TaskMaker.DELETION_TIME;
|
||||
import static org.tasks.makers.TaskMaker.DUE_DATE;
|
||||
import static org.tasks.makers.TaskMaker.DUE_TIME;
|
||||
import static org.tasks.makers.TaskMaker.ID;
|
||||
import static org.tasks.makers.TaskMaker.RANDOM_REMINDER_PERIOD;
|
||||
import static org.tasks.makers.TaskMaker.REMINDERS;
|
||||
import static org.tasks.makers.TaskMaker.REMINDER_LAST;
|
||||
import static org.tasks.makers.TaskMaker.SNOOZE_TIME;
|
||||
import static org.tasks.makers.TaskMaker.newTask;
|
||||
import static org.tasks.time.DateTimeUtils.currentTimeMillis;
|
||||
|
||||
@RunWith(AndroidJUnit4.class)
|
||||
public class ReminderServiceTest extends InjectingTestCase {
|
||||
|
||||
@Inject TaskDao taskDao;
|
||||
@Inject ReminderService reminderService;
|
||||
@Inject Preferences preferences;
|
||||
|
||||
@Override
|
||||
public void setUp() {
|
||||
super.setUp();
|
||||
freezeClock();
|
||||
}
|
||||
private ReminderService service;
|
||||
private JobQueue<Reminder> jobs;
|
||||
|
||||
@Override
|
||||
protected void inject(TestComponent component) {
|
||||
component.inject(this);
|
||||
@Before
|
||||
public void before() {
|
||||
jobs = mock(JobQueue.class);
|
||||
service = new ReminderService(preferences, jobs);
|
||||
}
|
||||
|
||||
@After
|
||||
public void tearDown() {
|
||||
thaw();
|
||||
public void after() {
|
||||
verifyNoMoreInteractions(jobs);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testNoReminders() {
|
||||
reminderService.setScheduler(new NoAlarmExpected());
|
||||
|
||||
Task task = new Task();
|
||||
task.setTitle("water");
|
||||
task.setReminderFlags(0);
|
||||
task.setReminderPeriod(0L);
|
||||
taskDao.save(task);
|
||||
reminderService.scheduleAlarm(taskDao, task);
|
||||
@Override
|
||||
protected void inject(TestComponent component) {
|
||||
component.inject(this);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testDueDates() {
|
||||
reminderService.setScheduler(new AlarmExpected() {
|
||||
@Override
|
||||
public void createAlarm(Task task, long time, int type) {
|
||||
if (time == ReminderService.NO_ALARM)
|
||||
return;
|
||||
super.createAlarm(task, time, type);
|
||||
assertEquals((long) task.getDueDate(), time);
|
||||
assertEquals(type, ReminderService.TYPE_DUE);
|
||||
}
|
||||
});
|
||||
|
||||
// test due date in the past
|
||||
final Task task = new Task();
|
||||
task.setTitle("water");
|
||||
task.setDueDate(DateUtilities.now() - DateUtilities.ONE_DAY);
|
||||
task.setReminderFlags(Task.NOTIFY_AT_DEADLINE);
|
||||
taskDao.save(task);
|
||||
|
||||
// test due date in the future
|
||||
task.setDueDate(DateUtilities.now() + DateUtilities.ONE_DAY);
|
||||
taskDao.save(task);
|
||||
assertTrue(((AlarmExpected) reminderService.getScheduler()).alarmCreated);
|
||||
public void dontScheduleDueDateReminderWhenFlagNotSet() {
|
||||
service.scheduleAlarm(null, newTask(with(ID, 1L), with(DUE_TIME, newDateTime())));
|
||||
|
||||
verify(jobs).cancel(1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testRandom() {
|
||||
// test random
|
||||
final Task task = new Task();
|
||||
task.setTitle("water");
|
||||
task.setReminderPeriod(DateUtilities.ONE_WEEK);
|
||||
reminderService.setScheduler(new AlarmExpected() {
|
||||
@Override
|
||||
public void createAlarm(Task task, long time, int type) {
|
||||
if (time == ReminderService.NO_ALARM)
|
||||
return;
|
||||
super.createAlarm(task, time, type);
|
||||
assertTrue(time > DateUtilities.now());
|
||||
assertTrue(time < DateUtilities.now() + 1.2 * DateUtilities.ONE_WEEK);
|
||||
assertEquals(type, ReminderService.TYPE_RANDOM);
|
||||
}
|
||||
});
|
||||
taskDao.save(task);
|
||||
assertTrue(((AlarmExpected) reminderService.getScheduler()).alarmCreated);
|
||||
public void dontScheduleDueDateReminderWhenTimeNotSet() {
|
||||
service.scheduleAlarm(null, newTask(with(ID, 1L), with(REMINDERS, NOTIFY_AT_DEADLINE)));
|
||||
|
||||
verify(jobs).cancel(1);
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testOverdue() {
|
||||
// test due date in the future
|
||||
reminderService.setScheduler(new AlarmExpected() {
|
||||
@Override
|
||||
public void createAlarm(Task task, long time, int type) {
|
||||
if (time == ReminderService.NO_ALARM)
|
||||
return;
|
||||
super.createAlarm(task, time, type);
|
||||
assertTrue(time > task.getDueDate());
|
||||
assertTrue(time < task.getDueDate() + DateUtilities.ONE_DAY);
|
||||
assertEquals(type, ReminderService.TYPE_OVERDUE);
|
||||
public void schedulePastDueDate() {
|
||||
Task task = newTask(
|
||||
with(ID, 1L),
|
||||
with(DUE_TIME, newDateTime().minusDays(1)),
|
||||
with(REMINDERS, NOTIFY_AT_DEADLINE));
|
||||
service.scheduleAlarm(null, task);
|
||||
|
||||
InOrder order = inOrder(jobs);
|
||||
order.verify(jobs).cancel(1);
|
||||
order.verify(jobs).add(new Reminder(1, task.getDueDate(), ReminderService.TYPE_DUE));
|
||||
}
|
||||
});
|
||||
final Task task = new Task();
|
||||
task.setTitle("water");
|
||||
task.setDueDate(DateUtilities.now() + DateUtilities.ONE_DAY);
|
||||
task.setReminderFlags(Task.NOTIFY_AFTER_DEADLINE);
|
||||
taskDao.save(task);
|
||||
|
||||
// test due date in the past
|
||||
task.setDueDate(DateUtilities.now() - DateUtilities.ONE_DAY);
|
||||
reminderService.setScheduler(new AlarmExpected() {
|
||||
@Override
|
||||
public void createAlarm(Task task, long time, int type) {
|
||||
if (time == ReminderService.NO_ALARM)
|
||||
return;
|
||||
super.createAlarm(task, time, type);
|
||||
assertTrue(time > DateUtilities.now() - 1000L);
|
||||
assertTrue(time < DateUtilities.now() + 2 * DateUtilities.ONE_DAY);
|
||||
assertEquals(type, ReminderService.TYPE_OVERDUE);
|
||||
}
|
||||
});
|
||||
taskDao.save(task);
|
||||
assertTrue(((AlarmExpected) reminderService.getScheduler()).alarmCreated);
|
||||
|
||||
// test due date in the past, but recently notified
|
||||
task.setReminderLast(DateUtilities.now());
|
||||
reminderService.setScheduler(new AlarmExpected() {
|
||||
@Override
|
||||
public void createAlarm(Task task, long time, int type) {
|
||||
if (time == ReminderService.NO_ALARM)
|
||||
return;
|
||||
super.createAlarm(task, time, type);
|
||||
assertTrue(time > DateUtilities.now() + DateUtilities.ONE_HOUR);
|
||||
assertTrue(time < DateUtilities.now() + DateUtilities.ONE_DAY);
|
||||
assertEquals(type, ReminderService.TYPE_OVERDUE);
|
||||
}
|
||||
});
|
||||
taskDao.save(task);
|
||||
assertTrue(((AlarmExpected) reminderService.getScheduler()).alarmCreated);
|
||||
@Test
|
||||
public void scheduleFutureDueDate() {
|
||||
Task task = newTask(
|
||||
with(ID, 1L),
|
||||
with(DUE_TIME, newDateTime().plusDays(1)),
|
||||
with(REMINDERS, NOTIFY_AT_DEADLINE));
|
||||
service.scheduleAlarm(null, task);
|
||||
|
||||
InOrder order = inOrder(jobs);
|
||||
order.verify(jobs).cancel(1);
|
||||
order.verify(jobs).add(new Reminder(1, task.getDueDate(), ReminderService.TYPE_DUE));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testMultipleReminders() {
|
||||
// test due date in the future, enable random
|
||||
final Task task = new Task();
|
||||
task.setTitle("water");
|
||||
task.setDueDate(DateUtilities.now() + DateUtilities.ONE_WEEK);
|
||||
task.setReminderFlags(Task.NOTIFY_AT_DEADLINE);
|
||||
task.setReminderPeriod(DateUtilities.ONE_HOUR);
|
||||
reminderService.setScheduler(new AlarmExpected() {
|
||||
@Override
|
||||
public void createAlarm(Task task, long time, int type) {
|
||||
if (time == ReminderService.NO_ALARM)
|
||||
return;
|
||||
super.createAlarm(task, time, type);
|
||||
assertTrue(time > DateUtilities.now());
|
||||
assertTrue(time < DateUtilities.now() + DateUtilities.ONE_DAY);
|
||||
assertEquals(type, ReminderService.TYPE_RANDOM);
|
||||
}
|
||||
});
|
||||
taskDao.save(task);
|
||||
assertTrue(((AlarmExpected) reminderService.getScheduler()).alarmCreated);
|
||||
|
||||
// now set the due date in the past
|
||||
task.setDueDate(DateUtilities.now() - DateUtilities.ONE_WEEK);
|
||||
((AlarmExpected) reminderService.getScheduler()).alarmCreated = false;
|
||||
reminderService.scheduleAlarm(taskDao, task);
|
||||
assertTrue(((AlarmExpected) reminderService.getScheduler()).alarmCreated);
|
||||
|
||||
// now set the due date before the random
|
||||
task.setDueDate(DateUtilities.now() + DateUtilities.ONE_HOUR);
|
||||
reminderService.setScheduler(new AlarmExpected() {
|
||||
@Override
|
||||
public void createAlarm(Task task, long time, int type) {
|
||||
if (time == ReminderService.NO_ALARM)
|
||||
return;
|
||||
super.createAlarm(task, time, type);
|
||||
assertEquals((long) task.getDueDate(), time);
|
||||
assertEquals(type, ReminderService.TYPE_DUE);
|
||||
}
|
||||
});
|
||||
taskDao.save(task);
|
||||
assertTrue(((AlarmExpected) reminderService.getScheduler()).alarmCreated);
|
||||
public void scheduleReminderAtDefaultDueTime() {
|
||||
DateTime now = newDateTime();
|
||||
Task task = newTask(
|
||||
with(ID, 1L),
|
||||
with(DUE_DATE, now),
|
||||
with(REMINDERS, NOTIFY_AT_DEADLINE));
|
||||
service.scheduleAlarm(null, task);
|
||||
|
||||
InOrder order = inOrder(jobs);
|
||||
order.verify(jobs).cancel(1);
|
||||
order.verify(jobs).add(new Reminder(1, now.startOfDay().withHourOfDay(18).getMillis(), ReminderService.TYPE_DUE));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testSnoozeReminders() {
|
||||
thaw(); // TODO: get rid of this
|
||||
|
||||
// test due date and snooze in the future
|
||||
final Task task = new Task();
|
||||
task.setTitle("spacemen");
|
||||
task.setDueDate(DateUtilities.now() + 5000L);
|
||||
task.setReminderFlags(Task.NOTIFY_AT_DEADLINE);
|
||||
task.setReminderSnooze(DateUtilities.now() + DateUtilities.ONE_WEEK);
|
||||
reminderService.setScheduler(new AlarmExpected() {
|
||||
@Override
|
||||
public void createAlarm(Task task, long time, int type) {
|
||||
if (time == ReminderService.NO_ALARM)
|
||||
return;
|
||||
super.createAlarm(task, time, type);
|
||||
assertTrue(time > DateUtilities.now() + DateUtilities.ONE_WEEK - 1000L);
|
||||
assertTrue(time < DateUtilities.now() + DateUtilities.ONE_WEEK + 1000L);
|
||||
assertEquals(type, ReminderService.TYPE_SNOOZE);
|
||||
}
|
||||
});
|
||||
taskDao.save(task);
|
||||
assertTrue(((AlarmExpected) reminderService.getScheduler()).alarmCreated);
|
||||
public void dontScheduleReminderForCompletedTask() {
|
||||
Task task = newTask(
|
||||
with(ID, 1L),
|
||||
with(DUE_TIME, newDateTime().plusDays(1)),
|
||||
with(COMPLETION_TIME, newDateTime()),
|
||||
with(REMINDERS, NOTIFY_AT_DEADLINE));
|
||||
|
||||
// snooze in the past
|
||||
task.setReminderSnooze(DateUtilities.now() - DateUtilities.ONE_WEEK);
|
||||
reminderService.setScheduler(new AlarmExpected() {
|
||||
@Override
|
||||
public void createAlarm(Task task, long time, int type) {
|
||||
if (time == ReminderService.NO_ALARM)
|
||||
return;
|
||||
super.createAlarm(task, time, type);
|
||||
assertTrue(time > DateUtilities.now() - 1000L);
|
||||
assertTrue(time < DateUtilities.now() + 5000L);
|
||||
assertEquals(type, ReminderService.TYPE_DUE);
|
||||
}
|
||||
});
|
||||
taskDao.save(task);
|
||||
assertTrue(((AlarmExpected) reminderService.getScheduler()).alarmCreated);
|
||||
service.scheduleAlarm(null, task);
|
||||
|
||||
verify(jobs).cancel(1);
|
||||
}
|
||||
|
||||
// --- helper classes
|
||||
@Test
|
||||
public void dontScheduleReminderForDeletedTask() {
|
||||
Task task = newTask(
|
||||
with(ID, 1L),
|
||||
with(DUE_TIME, newDateTime().plusDays(1)),
|
||||
with(DELETION_TIME, newDateTime()),
|
||||
with(REMINDERS, NOTIFY_AT_DEADLINE));
|
||||
|
||||
service.scheduleAlarm(null, task);
|
||||
|
||||
public class NoAlarmExpected implements AlarmScheduler {
|
||||
@Override
|
||||
public void createAlarm(Task task, long time, int type) {
|
||||
if(time == 0 || time == Long.MAX_VALUE)
|
||||
return;
|
||||
fail("created alarm, no alarm expected (" + type + ": " + newDateTime(time));
|
||||
verify(jobs).cancel(1);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void clear() {
|
||||
@Test
|
||||
public void dontScheduleDueDateReminderWhenAlreadyReminded() {
|
||||
DateTime now = newDateTime();
|
||||
Task task = newTask(
|
||||
with(ID, 1L),
|
||||
with(DUE_TIME, now),
|
||||
with(REMINDER_LAST, now.plusSeconds(1)),
|
||||
with(REMINDERS, NOTIFY_AT_DEADLINE));
|
||||
|
||||
}
|
||||
}
|
||||
service.scheduleAlarm(null, task);
|
||||
|
||||
public class AlarmExpected implements AlarmScheduler {
|
||||
public boolean alarmCreated = false;
|
||||
verify(jobs).cancel(1);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void createAlarm(Task task, long time, int type) {
|
||||
alarmCreated = true;
|
||||
@Test
|
||||
public void snoozeOverridesAll() {
|
||||
DateTime now = newDateTime();
|
||||
Task task = newTask(
|
||||
with(ID, 1L),
|
||||
with(DUE_TIME, now),
|
||||
with(SNOOZE_TIME, now.plusMonths(12)),
|
||||
with(REMINDERS, NOTIFY_AT_DEADLINE | NOTIFY_AFTER_DEADLINE),
|
||||
with(RANDOM_REMINDER_PERIOD, TimeUnit.HOURS.toMillis(1)));
|
||||
|
||||
service.scheduleAlarm(null, task);
|
||||
|
||||
InOrder order = inOrder(jobs);
|
||||
order.verify(jobs).cancel(1);
|
||||
order.verify(jobs).add(new Reminder(1, now.plusMonths(12).getMillis(), ReminderService.TYPE_SNOOZE));
|
||||
}
|
||||
|
||||
@Override
|
||||
public void clear() {
|
||||
@Test
|
||||
public void ignoreLapsedSnoozeTime() {
|
||||
Task task = newTask(
|
||||
with(ID, 1L),
|
||||
with(DUE_TIME, newDateTime()),
|
||||
with(SNOOZE_TIME, newDateTime().minusMinutes(5)),
|
||||
with(REMINDERS, NOTIFY_AT_DEADLINE));
|
||||
service.scheduleAlarm(null, task);
|
||||
|
||||
InOrder order = inOrder(jobs);
|
||||
order.verify(jobs).cancel(1);
|
||||
order.verify(jobs).add(new Reminder(1, task.getDueDate(), ReminderService.TYPE_DUE));
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void scheduleRandomReminder() {
|
||||
freezeClock().thawAfter(new Snippet() {{
|
||||
Task task = newTask(
|
||||
with(ID, 1L),
|
||||
with(RANDOM_REMINDER_PERIOD, TimeUnit.DAYS.toMillis(7)));
|
||||
service.scheduleAlarm(null, task);
|
||||
|
||||
ArgumentCaptor<Reminder> captor = ArgumentCaptor.forClass(Reminder.class);
|
||||
InOrder order = inOrder(jobs);
|
||||
order.verify(jobs).cancel(1);
|
||||
order.verify(jobs).add(captor.capture());
|
||||
|
||||
Reminder reminder = captor.getValue();
|
||||
assertTrue(reminder.getTime() > currentTimeMillis());
|
||||
assertTrue(reminder.getTime() < currentTimeMillis() + 1.2 * TimeUnit.DAYS.toMillis(7));
|
||||
assertEquals(TYPE_RANDOM, reminder.getType());
|
||||
}});
|
||||
}
|
||||
|
||||
// @Test
|
||||
// public void testOverdue() {
|
||||
// // test due date in the future
|
||||
// reminderService.setScheduler(new AlarmExpected() {
|
||||
// @Override
|
||||
// public void createAlarm(Task task, long time, int type) {
|
||||
// if (time == ReminderService.NO_ALARM)
|
||||
// return;
|
||||
// super.createAlarm(task, time, type);
|
||||
// assertTrue(time > task.getDueDate());
|
||||
// assertTrue(time < task.getDueDate() + DateUtilities.ONE_DAY);
|
||||
// assertEquals(type, ReminderService.TYPE_OVERDUE);
|
||||
// }
|
||||
// });
|
||||
// final Task task = new Task();
|
||||
// task.setTitle("water");
|
||||
// task.setDueDate(DateUtilities.now() + DateUtilities.ONE_DAY);
|
||||
// task.setReminderFlags(Task.NOTIFY_AFTER_DEADLINE);
|
||||
// taskDao.save(task);
|
||||
//
|
||||
// // test due date in the past
|
||||
// task.setDueDate(DateUtilities.now() - DateUtilities.ONE_DAY);
|
||||
// reminderService.setScheduler(new AlarmExpected() {
|
||||
// @Override
|
||||
// public void createAlarm(Task task, long time, int type) {
|
||||
// if (time == ReminderService.NO_ALARM)
|
||||
// return;
|
||||
// super.createAlarm(task, time, type);
|
||||
// assertTrue(time > DateUtilities.now() - 1000L);
|
||||
// assertTrue(time < DateUtilities.now() + 2 * DateUtilities.ONE_DAY);
|
||||
// assertEquals(type, ReminderService.TYPE_OVERDUE);
|
||||
// }
|
||||
// });
|
||||
// taskDao.save(task);
|
||||
// assertTrue(((AlarmExpected) reminderService.getScheduler()).alarmCreated);
|
||||
//
|
||||
// // test due date in the past, but recently notified
|
||||
// task.setReminderLast(DateUtilities.now());
|
||||
// reminderService.setScheduler(new AlarmExpected() {
|
||||
// @Override
|
||||
// public void createAlarm(Task task, long time, int type) {
|
||||
// if (time == ReminderService.NO_ALARM)
|
||||
// return;
|
||||
// super.createAlarm(task, time, type);
|
||||
// assertTrue(time > DateUtilities.now() + DateUtilities.ONE_HOUR);
|
||||
// assertTrue(time < DateUtilities.now() + DateUtilities.ONE_DAY);
|
||||
// assertEquals(type, ReminderService.TYPE_OVERDUE);
|
||||
// }
|
||||
// });
|
||||
// taskDao.save(task);
|
||||
// assertTrue(((AlarmExpected) reminderService.getScheduler()).alarmCreated);
|
||||
// }
|
||||
//
|
||||
// @Test
|
||||
// public void testMultipleReminders() {
|
||||
// // test due date in the future, enable random
|
||||
// final Task task = new Task();
|
||||
// task.setTitle("water");
|
||||
// task.setDueDate(DateUtilities.now() + DateUtilities.ONE_WEEK);
|
||||
// task.setReminderFlags(Task.NOTIFY_AT_DEADLINE);
|
||||
// task.setReminderPeriod(DateUtilities.ONE_HOUR);
|
||||
// reminderService.setScheduler(new AlarmExpected() {
|
||||
// @Override
|
||||
// public void createAlarm(Task task, long time, int type) {
|
||||
// if (time == ReminderService.NO_ALARM)
|
||||
// return;
|
||||
// super.createAlarm(task, time, type);
|
||||
// assertTrue(time > DateUtilities.now());
|
||||
// assertTrue(time < DateUtilities.now() + DateUtilities.ONE_DAY);
|
||||
// assertEquals(type, ReminderService.TYPE_RANDOM);
|
||||
// }
|
||||
// });
|
||||
// taskDao.save(task);
|
||||
// assertTrue(((AlarmExpected) reminderService.getScheduler()).alarmCreated);
|
||||
//
|
||||
// // now set the due date in the past
|
||||
// task.setDueDate(DateUtilities.now() - DateUtilities.ONE_WEEK);
|
||||
// ((AlarmExpected) reminderService.getScheduler()).alarmCreated = false;
|
||||
// reminderService.scheduleAlarm(taskDao, task);
|
||||
// assertTrue(((AlarmExpected) reminderService.getScheduler()).alarmCreated);
|
||||
//
|
||||
// // now set the due date before the random
|
||||
// task.setDueDate(DateUtilities.now() + DateUtilities.ONE_HOUR);
|
||||
// reminderService.setScheduler(new AlarmExpected() {
|
||||
// @Override
|
||||
// public void createAlarm(Task task, long time, int type) {
|
||||
// if (time == ReminderService.NO_ALARM)
|
||||
// return;
|
||||
// super.createAlarm(task, time, type);
|
||||
// assertEquals((long) task.getDueDate(), time);
|
||||
// assertEquals(type, ReminderService.TYPE_DUE);
|
||||
// }
|
||||
// });
|
||||
// taskDao.save(task);
|
||||
// assertTrue(((AlarmExpected) reminderService.getScheduler()).alarmCreated);
|
||||
// }
|
||||
}
|
||||
|
||||
@ -1,9 +0,0 @@
|
||||
package com.todoroo.astrid.reminders;
|
||||
|
||||
import com.todoroo.astrid.data.Task;
|
||||
|
||||
public interface AlarmScheduler {
|
||||
void createAlarm(Task task, long time, int type);
|
||||
|
||||
void clear();
|
||||
}
|
||||
@ -1,74 +0,0 @@
|
||||
package com.todoroo.astrid.reminders;
|
||||
|
||||
import com.todoroo.astrid.data.Task;
|
||||
|
||||
import org.tasks.injection.ApplicationScope;
|
||||
import org.tasks.jobs.JobManager;
|
||||
import org.tasks.jobs.JobQueue;
|
||||
import org.tasks.jobs.Reminder;
|
||||
import org.tasks.preferences.Preferences;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import javax.inject.Inject;
|
||||
|
||||
import static com.todoroo.astrid.reminders.ReminderService.NO_ALARM;
|
||||
|
||||
@ApplicationScope
|
||||
public class ReminderAlarmScheduler implements AlarmScheduler {
|
||||
|
||||
private final JobQueue<Reminder> jobs;
|
||||
private final JobManager jobManager;
|
||||
|
||||
@Inject
|
||||
public ReminderAlarmScheduler(JobManager jobManager, Preferences preferences) {
|
||||
this.jobManager = jobManager;
|
||||
jobs = new JobQueue<>(preferences);
|
||||
}
|
||||
|
||||
/**
|
||||
* Create an alarm for the given task at the given type
|
||||
*/
|
||||
@Override
|
||||
public void createAlarm(Task task, long time, int type) {
|
||||
long taskId = task.getId();
|
||||
if(taskId == Task.NO_ID) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (time == 0 || time == NO_ALARM) {
|
||||
if (jobs.cancel(taskId)) {
|
||||
scheduleNext(true);
|
||||
}
|
||||
} else {
|
||||
Reminder reminder = new Reminder(taskId, time, type);
|
||||
if (jobs.add(reminder)) {
|
||||
scheduleNext(true);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void clear() {
|
||||
jobs.clear();
|
||||
jobManager.cancelReminders();
|
||||
}
|
||||
|
||||
public void scheduleNextJob() {
|
||||
scheduleNext(false);
|
||||
}
|
||||
|
||||
private void scheduleNext(boolean cancelCurrent) {
|
||||
if (jobs.isEmpty()) {
|
||||
if (cancelCurrent) {
|
||||
jobManager.cancelReminders();
|
||||
}
|
||||
} else {
|
||||
jobManager.scheduleReminder(jobs.nextScheduledTime(), cancelCurrent);
|
||||
}
|
||||
}
|
||||
|
||||
public List<Reminder> removePastReminders() {
|
||||
return jobs.removeOverdueJobs();
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue