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 test_complete_task(self): due_date_list = DateGenerator().get_due_dates("every sa") tasks = Tasks(self.db) tasks.clear_objects() tasks.add("Repetitive task", "current", "home", "every sa") task_list = tasks.get_object_list() self.assertTrue(len(due_date_list) == len(task_list)) for task in task_list: task.complete() for task in task_list: self.assertTrue(task.is_completed())
def __init__(self, database): super().__init__(database, Task()) self.__calendar = Calendar() self.__vars = CommonVariables() self.__date_generator = DateGenerator()
class Tasks(Model): """ Main entry point for querying and managing local tasks. """ logger = AppLogger("tasks").get_logger() def __init__(self, database): super().__init__(database, Task()) self.__calendar = Calendar() self.__vars = CommonVariables() self.__date_generator = DateGenerator() def add(self, text, label, project, date_expression) -> List[Task]: assert type(text) and type(label) and type(project)\ and type(date_expression) is str task_list = list() if self.__date_generator.validate_input(date_expression): for due_date in self.__date_generator.get_due_dates( date_expression): task = Task(text) task.label = label task.project = project task.date_expression = date_expression task.due_date = due_date self.append(task) task_list.append(task) else: raise AttributeError( f"Provided date expression {date_expression} is invalid") return task_list def append(self, obj: Task): assert isinstance(obj, Task) return self.append_object(obj) 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_task(self, func) -> Task: for task in self.get_object_list(): if func(task) is not None: self.logger.debug( f"Retrieved task by index: {task.index}, text: {task.text}" ) return task def get_task_list(self): return sorted(self.get_object_list(), key=lambda task: task.due_date.date_string) def get_tasks_containing_text(self, value) -> List[Task]: """ Selects all tasks that with a text value that contain the provided value :param value: :return: list of Task """ assert type(value) is str return [ task for task in self.get_task_list() if str(value).lower() in str(task.text).lower() ] def get_tasks_matching_text(self, value) -> List[Task]: """ Selects all tasks with a text value that matches the provided value :param value: :return: """ assert type(value) is str return [ task for task in self.get_task_list() if str(value.lower() == str(task.text).lower()) ] def get_task_by_index(self, index: int) -> Task: assert type(index) is int return self.get_task(lambda task: task if task.index == index else None) def get_task_by_external_id(self, external_id: int) -> Task: assert type(external_id) is str return self.get_task(lambda task: task if task.external_id == external_id else None) def get_task_by_id(self, task_id: str) -> Task: assert type(task_id) is str return self.get_task(lambda task: task if task.unique_id == task_id else None) def get_task_by_name(self, task_name: str) -> Task: assert type(task_name) is str return self.get_task(lambda task: task if task.text == task_name else None) def get_tasks_by_date(self, date_expression: str) -> List[Task]: assert type(date_expression) is str task_list = list() for due_date in self.__date_generator.get_due_dates(date_expression): for task in self.get_task_list(): if task.due_date.date_string == due_date.date_string: task_list.append(task) return task_list def get_tasks_within_date_range(self, min_date_string: str, max_date_string: str) -> List[Task]: assert type(min_date_string) is str assert type(max_date_string) is str return [ task for task in self.get_task_list() if self.contains_due_date_range( task, min_date_string, max_date_string) ] def get_tasks_by_status(self, is_completed: bool) -> List[Task]: assert type(is_completed) is bool if is_completed: return [ task for task in self.get_task_list() if task.is_completed() ] else: return [ task for task in self.get_task_list() if not task.is_completed() ] def get_tasks_by_project(self, project: str) -> List[Task]: assert type(project) is str return self.get_list_by_type("project", project) def get_tasks_by_label(self, label: str) -> List[Task]: assert type(label) is str return self.get_list_by_type("label", label) def get_filtered_list(self) -> List[Task]: return [task for task in self.get_task_list() if not task.deleted] def delete(self, task_id: str) -> Task: assert type(task_id) is str task = self.get_task_by_id(task_id) if task is not None: task.deleted = True self.replace_object(task.index, task) return task else: raise TaskKeyError() def undelete(self, task_id: str) -> Task: assert type(task_id) is str task = self.get_task_by_id(task_id) if task is not None: task.deleted = False self.replace_object(task.index, task) return task else: raise TaskKeyError() def complete(self, task_id: str) -> Task: assert type(task_id) is str task = self.get_task_by_id(task_id) if task is not None: task.complete() self.replace_object(task.index, task) return task else: raise TaskKeyError() def reset(self, task_id: str) -> Task: """ Resets the due date to today on the selected task :param task_id: :return: """ assert type(task_id) is str task = self.get_task_by_id(task_id) if task is not None: due_date = DueDate() due_date.completed = False due_date.date_string = Today().to_date_string() task.due_date = due_date self.replace_object(task.index, task) return task else: raise TaskKeyError() def replace(self, local_task: Task, remote_task: Task) -> Task: assert isinstance(remote_task, Task) assert isinstance(local_task, Task) remote_task.index = local_task.index remote_task.unique_id = local_task.unique_id remote_task.due_date = local_task.due_date self.replace_object(local_task.index, remote_task) self.logger.debug( f"Replaced local_task: {dict(local_task)} with remote_task: {dict(remote_task)}" ) return remote_task def edit(self, index: int, text: str, label: str, project: str, date_expression: str) -> Task: task = self.get_task_by_index(index) if task is not None: task.text = text task.project = project task.label = label due_date = self.__date_generator.get_due_date(date_expression) if due_date is not None: task.date_expression = date_expression task.due_date.date_string = due_date.date_string self.replace_object(task.index, task) return task else: raise TaskKeyError() def reschedule(self, today) -> None: assert type(today) is Today or Day task_list = self.get_task_list() for task in task_list: if self.__calendar.is_past( task.due_date, today ) and task.due_date.completed is False and task.deleted is False: task.due_date.date_string = today.to_date_string() self.update_objects(task_list) def get_list_by_type(self, parameter_name: str, value: str, task_list=None) -> list: """ Returns list of tasks when a task parameter (ie. project, text, label) matches a single value. :param parameter_name: :param value: :param task_list: :return: """ assert type(parameter_name) is str assert type(value) is str if task_list is None: task_list = self.get_task_list() else: assert type(task_list) is list return list( filter(lambda t: getattr(t, parameter_name) == value, task_list)) def __sort(self, parameter_name: str) -> list: assert type(parameter_name) is str return [ t for t in sorted(self.get_task_list(), key=lambda t: getattr(t, parameter_name)) ] def get_label_list(self) -> List[str]: return self.unique("label", self.get_task_list()) def get_project_list(self) -> List[str]: return self.unique("project", self.get_task_list()) def get_due_date_list(self) -> List[str]: return list( set([task.due_date.date_string for task in self.get_task_list()])) @staticmethod def unique(parameter_name: str, task_list: list) -> List[str]: assert type(parameter_name) is str assert type(task_list) is list unique_set = set([getattr(task, parameter_name) for task in task_list]) return sorted(list(unique_set)) def clear(self): self.clear_objects()
def __init__(self, db_manager): assert isinstance(db_manager, DatabaseManager) self.tasks = db_manager.get_tasks_model() self.__date_generator = DateGenerator() self.__variables = CommonVariables()
class Client: """ Base client facade that that provides access to all the application features. It integrates the import/export, tasks, snapshot, common variables, and date generator classes. It also makes it possible to support additional clients. Currently only the console client is supported, but a rest api could also extend this class. """ logger = AppLogger("client").get_logger() def __init__(self, db_manager): assert isinstance(db_manager, DatabaseManager) self.tasks = db_manager.get_tasks_model() self.__date_generator = DateGenerator() self.__variables = CommonVariables() @abstractmethod def display_tasks(self, task_list: list): pass @abstractmethod def display_snapshots(self, snapshots: Snapshots, **kwargs): pass @abstractmethod def display_invalid_index_error(self, index: int): pass def edit_task(self, index: int, text: str, label: str, project: str, date_expression: str) -> List[Task]: """ Edits an existing task by replacing string values. None are allowed and handled by the Task object. :param index: integer starting at 0 :param text: text string describing the task :param label: label name of the task :param project: project name of the task :param date_expression: Must be one of [today, tomorrow, m-s, every *, month / day, etc]. :return: Task """ assert type(index) is int assert type(text) is str assert type(project) is str assert type(label) is str assert type(date_expression) is str try: if self.__date_generator.validate_input(date_expression) is False: self.logger.info( f"Provided due date {date_expression} is invalid") else: task = self.tasks.edit(index, text, label, project, date_expression) return self.display_tasks([task]) except TaskKeyError: self.display_invalid_index_error(index) def get_task(self, task_index: int) -> List[Task]: task = self.tasks.get_task_by_index(int(task_index)) return self.display_tasks([task]) def filter_tasks_by_today(self) -> List[Task]: date_string = Today().to_date_string() task_list = self.tasks.get_tasks_by_date(date_string) return self.display_tasks(task_list) def filter_tasks_by_due_date(self, date_string: str) -> List[Task]: task_list = self.tasks.get_tasks_by_date(date_string) return self.display_tasks(task_list) def filter_tasks_by_due_date_range(self, min_date: str, max_date: str) -> List[Task]: task_list = self.tasks.get_tasks_within_date_range(min_date, max_date) return self.display_tasks(task_list) def filter_tasks_by_status(self, status: str) -> List[Task]: assert status in ["incomplete", "complete"] if status == "incomplete": task_list = self.tasks.get_tasks_by_status(is_completed=False) else: task_list = self.tasks.get_tasks_by_status(is_completed=True) return self.display_tasks(task_list) def filter_tasks_by_project(self, project: str) -> List[Task]: assert type(project) is str task_list = self.tasks.get_tasks_by_project(project) return self.display_tasks(task_list) def filter_tasks_by_label(self, label: str) -> List[Task]: assert type(label) is str task_list = self.tasks.get_tasks_by_label(label) return self.display_tasks(task_list) def filter_tasks_by_text(self, text: str) -> List[Task]: assert type(text) is str task_list = self.tasks.get_tasks_containing_text(text) return self.display_tasks(task_list) def group_tasks_by_project(self) -> List[Task]: task_list = list() for project in self.get_unique_project_list(): for task in self.tasks.get_tasks_by_project(project): task_list.append(task) return self.display_tasks(task_list) def group_tasks_by_due_date(self) -> List[Task]: task_list = list() for due_date_string in self.__get_unique_due_date_list(): for task in self.tasks.get_tasks_by_date(due_date_string): task_list.append(task) return self.display_tasks(task_list) def group_tasks_by_label(self) -> List[Task]: task_list = list() for label in self.get_unique_label_list(): for task in self.tasks.get_tasks_by_label(label): task_list.append(task) return self.display_tasks(task_list) def get_unique_label_list(self) -> List[str]: """Returns a list of labels from the tasks.""" return self.tasks.get_label_list() def get_unique_project_list(self) -> List[str]: """Returns list of project names from the tasks. """ return self.tasks.get_project_list() def __get_unique_due_date_list(self) -> List[str]: """Returns list of due_date strings from the tasks.""" return self.tasks.get_due_date_list() def count_all_tasks(self, **kwargs) -> List[Snapshot]: snapshots = Snapshots(self.tasks) snapshots.count_all_tasks() return self.display_snapshots(snapshots, **kwargs) def count_tasks_by_due_date_range(self, min_date: str, max_date: str, **kwargs) -> List[Snapshot]: assert type(min_date) and type(max_date) is str snapshots = Snapshots(self.tasks) snapshots.count_tasks_by_due_date_range(min_date, max_date) return self.display_snapshots(snapshots, **kwargs) def count_tasks_by_due_date(self, due_date: str, **kwargs) -> List[Snapshot]: assert type(due_date) is str snapshots = Snapshots(self.tasks) snapshots.count_tasks_by_due_date(due_date) return self.display_snapshots(snapshots, **kwargs) def count_tasks_by_project(self, project_name: str, **kwargs) -> List[Snapshot]: assert type(project_name) is str snapshots = Snapshots(self.tasks) snapshots.count_tasks_by_project(project_name) return self.display_snapshots(snapshots, **kwargs) def reschedule_tasks(self, today=Today()): self.tasks.reschedule(today) def remove_all_tasks(self): self.tasks.clear() def set_default_variables(self, **kwargs): """ Sets the defaults variables to the variables.ini file. :param variable_dict: Contains key value pairs matching the properties in Variables class :return: None """ assert type(kwargs) is dict for key, value in kwargs.items(): if hasattr(self.__variables, key): setattr(self.__variables, key, value) @staticmethod def get_duration(start_datetime): """ Gets a formatted time string using the provided datetime object :param start_datetime: :return: time string """ end_datetime = datetime.now() total_seconds = (end_datetime - start_datetime).total_seconds() hours, remainder = divmod(total_seconds, 3600) minutes, seconds = divmod(remainder, 60) return '{:02}m:{:02}s'.format(int(minutes), int(seconds)) @staticmethod def get_variables_list(): return dict(CommonVariables()).items()
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)
class TestDateGenerator(unittest.TestCase): 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_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 setUp(self): self.today = Today() self.vars = CommonVariables() self.date_generator = DateGenerator() self.march1 = datetime.strptime('2019-03-01', self.vars.date_format) def tearDown(self): pass 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_in_same_week(self): self.assertTrue(self.match_date('2019-03-12', 'w', '2019-03-13')) def test_get_date_when_in_next_week(self): self.assertTrue(self.match_date('2019-03-12', 'm', '2019-03-18')) def test_get_date_when_in_next_month(self): self.assertTrue(self.match_date('2019-03-29', 'tu', '2019-04-02')) def test_get_date_when_today(self): self.assertTrue( self.match_date(self.today.to_date_string(), 'today', self.today.to_date_string())) def test_get_date_when_tomorrow(self): self.assertTrue(self.match_date('2019-03-29', 'tomorrow', '2019-03-30')) def test_get_date_when_next_week(self): self.assertTrue( self.match_date('2019-03-17', 'next week', '2019-03-18')) self.assertTrue( self.match_date('2019-03-18', 'next week', '2019-03-25')) self.assertTrue( self.match_date('2019-03-29', 'next week', '2019-04-01')) def test_get_date_when_next_month(self): self.assertTrue( self.match_date('2019-07-02', 'next month', '2019-08-01')) self.assertTrue( self.match_date('2019-12-02', 'next month', '2020-01-01')) 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 test_get_date_count_when_every_weekday(self): self.vars.recurring_month_limit = 2 day_count = self.get_date_count('2019-03-01', 'every weekday') self.assertTrue(day_count == 44) 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 test_get_date_when_every_sunday(self): self.vars.recurring_month_limit = 2 self.assertTrue(self.get_date_count('2019-03-01', 'every su') == 9) def test_get_date_when_every_monday(self): self.vars.recurring_month_limit = 2 self.assertTrue(self.get_date_count('2019-03-01', 'every m') == 9) def test_get_date_when_every_tuesday(self): self.vars.recurring_month_limit = 2 self.assertTrue(self.get_date_count('2019-03-01', 'every tu') == 9) def test_get_date_when_every_wednesday(self): self.vars.recurring_month_limit = 2 self.assertTrue(self.get_date_count('2019-03-01', 'every w') == 9) def test_get_date_when_every_thursday(self): self.vars.recurring_month_limit = 2 self.assertTrue(self.get_date_count('2019-03-01', 'every th') == 8) def test_get_date_when_every_friday(self): self.vars.recurring_month_limit = 2 day_count = self.get_date_count('2019-03-01', 'every f') self.assertTrue(day_count == 9) def test_get_date_when_every_saturday(self): self.vars.recurring_month_limit = 2 self.assertTrue(self.get_date_count('2019-03-01', 'every sa') == 9) def test_short_date(self): due_date_list = self.date_generator.get_due_dates("apr 14") self.assertTrue(len(due_date_list) == 1) self.assertTrue(due_date_list[0].date_string == '2021-04-14') def test_validate_input(self): self.assertTrue(self.date_generator.validate_input("every weekday")) self.assertTrue(self.date_generator.validate_input("every tu")) self.assertTrue(self.date_generator.validate_input("m")) self.assertTrue(self.date_generator.validate_input("today")) self.assertFalse(self.date_generator.validate_input("every")) self.assertFalse(self.date_generator.validate_input("24")) self.assertFalse(self.date_generator.validate_input("monday")) self.assertTrue(self.date_generator.validate_input("apr 21")) self.assertFalse(self.date_generator.validate_input("apr")) def test_empty_date_handler(self): due_date_list = self.date_generator.get_due_dates("empty") self.assertTrue(len(due_date_list) == 1) due_date = due_date_list[0] self.assertEqual(due_date.date_string, "") self.assertFalse(due_date.completed) def test_year_month_date_handler(self): due_date_list = self.date_generator.get_due_dates("2019-03-019") self.assertTrue(len(due_date_list) == 1) self.assertFalse(due_date_list[0].completed) due_date_list = self.date_generator.get_due_dates("2019-03-01") self.assertTrue(len(due_date_list) == 1) self.assertFalse(due_date_list[0].completed) self.assertTrue(due_date_list[0].date_string == "2019-03-01") def test_get_due_date(self): due_date = self.date_generator.get_due_date("this week") self.assertTrue(len(due_date.date_string) == 0) due_date = self.date_generator.get_due_date("sep 24") self.assertIn("09-24", due_date.date_string)
def setUp(self): self.today = Today() self.vars = CommonVariables() self.date_generator = DateGenerator() self.march1 = datetime.strptime('2019-03-01', self.vars.date_format)