def get_work_week_days(start_day: Day, month_count: int) -> List[Day]:
"""
Gets all days within a work week from today until the end of the month
:param start_day: Day object
:param month_count: number of months
:return: list of date strings
"""
assert type(start_day) is Day
assert type(month_count) is int
start = start_day.to_date_time()
end = start + relativedelta(months=month_count)
days = list(rrule(DAILY, wkst=MO, byweekday=(MO, TU, WE, TH, FR), dtstart=start, until=end))
return [Day(dt) for dt in days]
def get_day(today: Day, weekday_number: int) -> Day:
"""
Gets the next calendar day in current week, next week, or next month that
matches the provided weekday_number.
:param today: Day object
:param weekday_number: integer (ie. 0-6) m=0, su=6
:return: Day object
"""
assert type(today) is Day
assert type(weekday_number) is int
today = today.to_date_time()
date_list = list(rrule(DAILY, count=1, wkst=MO, byweekday=weekday_number, dtstart=today))
if date_list:
return Day(date_list[0])
def match_date(self, current_date_string, date_expression,
expected_date_string):
current_date_time = datetime.strptime(current_date_string,
CommonVariables().date_format)
self.date_generator.current_day = Day(current_date_time)
due_date_list = self.date_generator.get_due_dates(date_expression)
return due_date_list[0].date_string == expected_date_string
def get_week_days(start_day: Day, weekday_number: int, month_count: int) -> List[Day]:
"""
Returns all the days for the provided week day in a month.
:param start_day: Day object
:param weekday_number: integer (ie. 0-6) m=0 and su=6
:param month_count: number of months
:return: list of Days
"""
assert type(start_day) is Day
assert type(weekday_number) is int
assert type(month_count) is int
start = start_day.to_date_time()
end = start + relativedelta(months=month_count)
days = list(rrule(DAILY, wkst=MO, byweekday=weekday_number, dtstart=start, until=end))
return [Day(dt) for dt in days]
def test_get_date_when_every_weekday(self):
self.vars.recurring_month_limit = 2
self.date_generator.current_day = Day(self.march1)
due_date_list = self.date_generator.get_due_dates("every weekday")
self.assertTrue(len(due_date_list) == 44)
self.assertTrue(due_date_list[0].date_string == "2019-03-01")
self.assertTrue(due_date_list[1].date_string == "2019-03-04")
self.assertTrue(due_date_list[2].date_string == "2019-03-05")
self.assertTrue(due_date_list[3].date_string == "2019-03-06")
self.assertTrue(due_date_list[4].date_string == "2019-03-07")
def contains_due_date_range(self, task, min_date_string, max_date_string):
assert isinstance(task, Task)
assert type(min_date_string) and type(max_date_string) is str
min_day = Day(
datetime.strptime(min_date_string, self.__vars.date_format))
max_day = Day(
datetime.strptime(max_date_string, self.__vars.date_format))
if len(task.due_date.date_string) > 0:
day = Day(
datetime.strptime(task.due_date.date_string,
self.__vars.date_format))
if min_day.to_date_time() < day.to_date_time(
) < max_day.to_date_time():
return task
def get_closest_due_date(self, due_dates: List[DueDate], current_day=None) -> DueDate:
"""
Returns a future date string that is the closest to the current day
:param due_dates: list of due_date objects with the format yyyy-mm-dd
:param current_day: Day object
:return:
Date string
"""
if current_day is None:
current_day = Today()
diff_list = []
# calculate the difference between current day and date string
for due_date in due_dates:
if len(due_date.date_string) > 0:
day = Day(datetime.strptime(due_date.date_string, self.vars.date_format))
timedelta1 = day.to_date_time() - current_day.to_date_time()
diff_list.append(timedelta1.days)
# return the date string using the smallest difference
for index, diff_num in enumerate(diff_list):
if diff_num >= 0:
return due_dates[index]
def setUp(self) -> None:
self.calendar = Calendar()
self.vars = CommonVariables()
self.march1 = Day(
datetime.strptime('2019-03-01', self.vars.date_format))
self.march31 = Day(
datetime.strptime('2019-03-31', self.vars.date_format))
self.may31 = Day(datetime.strptime('2019-05-31',
self.vars.date_format))
self.dec1 = Day(datetime.strptime("2019-12-01", self.vars.date_format))
self.dec31 = Day(datetime.strptime("2019-12-31",
self.vars.date_format))
self.june4 = Day(datetime.strptime("2021-06-04",
self.vars.date_format))
self.june7 = Day(datetime.strptime("2021-06-07",
self.vars.date_format))
self.june9 = Day(datetime.strptime("2021-06-09",
self.vars.date_format))
self.june11 = Day(
datetime.strptime("2021-06-11", self.vars.date_format))
self.june29 = Day(
datetime.strptime("2021-07-02", self.vars.date_format))
def get_days(start_day, month_count: int = 1) -> List[Day]:
"""
Gets all the days from today until the end of the month.
:param month_count: number of months
:param start_day: Day object
:return: list of date string
"""
assert type(start_day) is Day
assert type(month_count) is int
start = start_day.to_date_time()
end = start + relativedelta(months=month_count)
days = list(rrule(freq=DAILY, dtstart=start, until=end))
return [Day(dt) for dt in days]
def setUp(self):
self.vars = CommonVariables('test_variables.ini')
mgr = DatabaseManager(self.vars)
self.tasks = mgr.get_tasks_model()
self.client = CliClient(mgr, MockFileManager())
self.client.remove_all_tasks()
self.date_generator = DateGenerator()
self.june4 = Day(datetime.strptime("2021-06-04",
self.vars.date_format))
self.june7 = Day(datetime.strptime("2021-06-07",
self.vars.date_format))
self.june9 = Day(datetime.strptime("2021-06-09",
self.vars.date_format))
def parse_date(expression: str) -> Day:
return Day(parse(expression))
def get_next_month(self, day: Day) -> List[Day]:
last_day = self.get_last_day_in_month(day)
future_day = Day(last_day.to_date_time() + timedelta(days=1))
return self.fill(future_day, self.get_last_day_in_month(deepcopy(future_day)))
def get_last_month(self, day: Day) -> List[Day]:
first_day = self.get_first_day_in_month(day)
past_day = Day(first_day.to_date_time() - timedelta(days=1))
return self.fill(self.get_first_day_in_month(deepcopy(past_day)), past_day)
def get_next_week(self, day: Day) -> List[Day]:
future_day = Day(day.to_date_time() + timedelta(days=7))
return self.fill(self.get_first_day_in_week(deepcopy(future_day)), self.get_last_day_in_week(deepcopy(future_day)))
def fill(start_day: Day, end_day: Day) -> List[Day]:
days = list(rrule(freq=DAILY, dtstart=start_day.to_date_time(), until=end_day.to_date_time()))
return [Day(dt) for dt in days]
def get_tomorrow(day: Day) -> Day:
return Day(day.to_date_time() + timedelta(days=1))
class TestCliClient(unittest.TestCase):
def setUp(self):
self.vars = CommonVariables('test_variables.ini')
mgr = DatabaseManager(self.vars)
self.tasks = mgr.get_tasks_model()
self.client = CliClient(mgr, MockFileManager())
self.client.remove_all_tasks()
self.date_generator = DateGenerator()
self.june4 = Day(datetime.strptime("2021-06-04",
self.vars.date_format))
self.june7 = Day(datetime.strptime("2021-06-07",
self.vars.date_format))
self.june9 = Day(datetime.strptime("2021-06-09",
self.vars.date_format))
def tearDown(self):
self.client.remove_all_tasks()
def test_add_task(self):
self.client.add_task("Clean garage", "", "home", "empty")
self.client.list_all_tasks()
row_count = len(self.client.task_table.get_table().rows)
self.assertTrue(row_count == 1)
def test_list_all_tasks(self):
self.client.add_task("Clean car", "@waiting_on", "home", "today")
self.client.add_task("Clean bathroom", "", "home", "tomorrow")
self.client.add_task("Book flight to New York", "@at_computer", "work",
"m")
self.client.add_task("Repair deck", "@waiting_on", "home", "sa")
self.client.add_task("Call friend for birthday", "@call", "home", "m")
self.client.add_task("Paint picture", "@idea", "home", "sa")
self.client.add_task("Build puzzle with family", "@idea", "home", "su")
self.client.add_task("Schedule meeting with SW team", "@meeting",
"work", "m")
self.client.add_task("Create facebook 2.0 app", "@idea", "", "empty")
rows = self.client.list_all_tasks()
self.assertTrue(len(rows) == 9)
def test_list_tasks_by_label(self):
self.client.add_task("Clean car", "@waiting_on", "home", "today")
self.client.add_task("Clean bathroom", "", "home", "tomorrow")
self.client.add_task("Book flight to New York", "@at_computer", "work",
"m")
self.client.add_task("Repair deck", "@waiting_on", "home", "sa")
self.client.add_task("Call friend for birthday", "@call", "home", "m")
self.client.add_task("Paint picture", "@idea", "home", "sa")
self.client.add_task("Build puzzle with family", "@idea", "home", "su")
self.client.add_task("Schedule meeting with SW team", "@meeting",
"work", "m")
self.client.add_task("Create facebook 2.0 app", "@idea", "", "empty")
rows = self.client.group_tasks_by_label()
self.assertTrue(len(rows) == 9)
def test_list_tasks_by_project(self):
self.client.add_task("Clean car", "@waiting_on", "home", "today")
self.client.add_task("Clean bathroom", "", "home", "tomorrow")
self.client.add_task("Book flight to New York", "@at_computer", "work",
"m")
self.client.add_task("Repair deck", "@waiting_on", "home", "sa")
self.client.add_task("Call friend for birthday", "@call", "home", "m")
self.client.add_task("Paint picture", "@idea", "home", "sa")
self.client.add_task("Build puzzle with family", "@idea", "home", "su")
self.client.add_task("Schedule meeting with SW team", "@meeting",
"work", "m")
self.client.add_task("Create facebook 2.0 app", "@idea", "", "empty")
rows = self.client.group_tasks_by_project()
self.assertTrue(len(rows) == 9)
def test_encoding_decoding_date_string(self):
now = datetime.now()
date_string = now.strftime("%m-%d-%Y")
date_object = datetime.strptime(date_string, "%m-%d-%Y")
self.assertIsInstance(date_object, datetime)
def test_edit_task_using_all_fields(self):
self.client.add_task("Clean car", "deprecated", "home", "today")
task_list = self.client.edit_task(1, "text_value", "current", "work",
"apr 14")
self.assertTrue(len(task_list) == 1)
task = task_list[0]
self.assertEqual(task.text, 'text_value')
self.assertEqual(task.label, "current")
self.assertEqual(task.deleted, False)
self.assertEqual(task.priority, 1)
self.assertEqual(task.project, 'work')
self.assertEqual(task.date_expression, 'apr 14')
self.assertEqual(task.due_date.date_string, '2021-04-14')
self.assertEqual(task.due_date.completed, False)
def test_today(self):
self.client.add_task("task1", "home", "home", "empty")
self.client.add_task("task2", "home", "home", "today")
rows = self.client.filter_tasks_by_today()
self.assertTrue(len(list(rows)) == 1)
def test_delete(self):
self.client.add_task("Clean car", "@waiting_on", "home", "today")
self.client.add_task("Clean bathroom", "", "home", "tomorrow")
task_list = self.client.delete_tasks((
1,
2,
))
self.assertTrue(len(task_list) == 2)
self.assertTrue(task_list[0].deleted)
self.assertTrue(task_list[1].deleted)
def test_complete(self):
due_dates = self.date_generator.get_due_dates("every m")
task_list = self.client.add_task("task1", "home", "home", "every m")
for task in task_list:
self.client.complete_tasks((task.index, ))
rows = self.client.list_all_tasks()
self.assertTrue(len(due_dates) == len(rows))
done_list = [row.due_date.completed for row in rows]
self.assertIsNotNone(done_list)
self.assertTrue("False" not in done_list)
def test_count_all_tasks(self):
self.tasks.add("task1", "label1", "project1", "today")
snapshot_list = self.client.count_all_tasks(**{"page": 1})
self.assertIsNotNone(snapshot_list)
self.assertTrue(len(snapshot_list) == 1)
def test_count_by_date(self):
self.tasks.add("task1", "label1", "project1", "today")
date_string = Today().to_date_string()
snapshot_list = self.client.count_tasks_by_due_date(
date_string, **{"page": 1})
self.assertTrue(len(snapshot_list) == 1)
snapshot = snapshot_list[0]
self.assertTrue(snapshot.count == 1)
def test_count_by_due_date_range(self):
june4_date_string = self.june4.to_date_string()
june9_date_string = self.june9.to_date_string()
self.tasks.add("task1", "current", "work", june4_date_string)
self.tasks.add("task2", "current", "work", self.june7.to_date_string())
self.tasks.add("task3", "current", "work", june9_date_string)
snapshot_list = self.client.count_tasks_by_due_date_range(
june4_date_string, june9_date_string, **{"page": 1})
self.assertTrue(len(snapshot_list) == 1)
def test_count_by_project(self):
date_string = Today().to_date_string()
self.tasks.add("task1", "current", "work", date_string)
self.tasks.add("task2", "current", "work", date_string)
self.tasks.add("task3", "current", "work", date_string)
snapshot_list = self.client.count_tasks_by_project(
"work", **{"page": 1})
self.assertTrue(len(snapshot_list) == 1)
snapshot = snapshot_list[0]
self.assertTrue(snapshot.count == 3)
def test_count_by_project_with_incorrect_value(self):
self.tasks.add("task1", "current", "work", "today")
snapshot_list = self.client.count_tasks_by_project(
"work2", **{"page": 1})
self.assertTrue(len(snapshot_list) == 0)
def get_last_day_in_week(day: Day) -> Day:
return Day(day.to_date_time() + timedelta(days=(6 - day.weekday_number)))
def get_first_day_in_week(day: Day) -> Day:
return Day(day.to_date_time() - timedelta(days=day.weekday_number))
def test_contains_day(self):
day = Day(datetime.strptime("2021-04-14", self.vars.date_format))
result = self.calendar.contains_month(
[DueDate("2021-04-14"),
DueDate("2021-04-21")], day)
self.assertTrue(result)
def get_date_count(self, current_date_string, date_expression):
current_date_time = datetime.strptime(current_date_string,
CommonVariables().date_format)
self.date_generator.current_day = Day(current_date_time)
due_date_list = self.date_generator.get_due_dates(date_expression)
return len(due_date_list)
def test_pad_number(self):
current_date_time = datetime.strptime('2019-03-12',
self.vars.date_format)
day = Day(current_date_time)
date_list = day.to_date_list()
self.assertListEqual(date_list, ['2019-03-12'])
def test_get_date_when_every_day(self):
self.date_generator.current_day = Day(self.march1)
due_date_list = self.date_generator.get_due_dates("every day")
self.assertTrue(len(due_date_list) == 62)
def contains_week(due_dates: List[DueDate], selected_day=Today()) -> bool:
return Calendar.contains(due_dates, lambda due_date: Day(due_date.to_date_time()).week == selected_day.week)
def get_first_day_in_month(day: Day) -> Day:
day.day_number = 1
return day
def get_yesterday(day: Day) -> Day:
return Day(day.to_date_time() - timedelta(days=1))
def current_day(self):
if self.__current_day is None:
return Day(datetime.now())
else:
return self.__current_day
def get_last_day_in_month(self, day: Day) -> Day:
day.day_number = self.get_day_count_in_month(day)
return day
