#!/usr/bin/env python3 # -*- coding: utf-8 -*- ############################################################################### # # Copyright 2006 - 2021, Tomas Babej, Paul Beckingham, Federico Hernandez. # # Permission is hereby granted, free of charge, to any person obtaining a copy # of this software and associated documentation files (the "Software"), to deal # in the Software without restriction, including without limitation the rights # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the Software is # furnished to do so, subject to the following conditions: # # The above copyright notice and this permission notice shall be included # in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS # OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL # THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE # SOFTWARE. # # https://www.opensource.org/licenses/mit-license.php # ############################################################################### import sys import os import unittest import re # Ensure python finds the local simpletap module sys.path.append(os.path.dirname(os.path.abspath(__file__))) from basetest import Task, TestCase class ContextManagementTest(TestCase): def setUp(self): self.t = Task() def test_context_define_confirmation(self): """With confirmation active, prompt if context filter matches no tasks""" self.t.config("confirmation", "on") code, out, err = self.t.runError('context define work project:Work', input="y\nn\n") self.assertIn("The filter 'project:Work' matches 0 pending tasks.", out) self.assertNotIn("Context 'work' defined", out) # Assert the config contains context definition self.assertNotIn('context.work=project:Work\n', self.t.taskrc_content) def test_context_define(self): """Test simple context definition.""" code, out, err = self.t('context define work project:Work', input="y\ny\nn\n") self.assertIn("Context 'work' defined", out) # Assert the config contains read context definition context_line = 'context.work.read=project:Work\n' self.assertIn(context_line, self.t.taskrc_content) # Assert that it contains the definition only once self.assertEqual(self.t.taskrc_content.count(context_line), 1) # Assert the config does not contain write context definition context_line = 'context.work.write=project:Work\n' self.assertNotIn(context_line, self.t.taskrc_content) # Assert that legacy style was not used # Assert the config contains read context definition context_line = 'context.work=project:Work\n' self.assertNotIn(context_line, self.t.taskrc_content) def test_context_redefine_same_definition(self): """Test re-defining the context with the same definition.""" self.t('context define work project:Work', input='y\ny\ny\n') code, out, err = self.t('context define work project:Work', input='y\ny\ny\n') self.assertIn("Context 'work' defined (read, write).", out) # Assert the config contains context definition context_line = 'context.work.read=project:Work\n' self.assertIn(context_line, self.t.taskrc_content) self.assertEqual(self.t.taskrc_content.count(context_line), 1) context_line = 'context.work.write=project:Work\n' self.assertIn(context_line, self.t.taskrc_content) self.assertEqual(self.t.taskrc_content.count(context_line), 1) def test_context_redefine_different_definition(self): """Test re-defining the context with different definition.""" self.t('context define work project:Work', input='y\ny\ny\n') code, out, err = self.t('context define work +work', input='y\ny\ny\n') self.assertIn("Context 'work' defined", out) # Assert the config does not contain the old context definition self.assertNotIn('context.work.read=project:Work\n', self.t.taskrc_content) self.assertNotIn('context.work.write=project:Work\n', self.t.taskrc_content) # Assert the config contains context definition context_line = 'context.work.read=+work\n' self.assertIn(context_line, self.t.taskrc_content) self.assertEqual(self.t.taskrc_content.count(context_line), 1) context_line = 'context.work.write=+work\n' self.assertIn(context_line, self.t.taskrc_content) self.assertEqual(self.t.taskrc_content.count(context_line), 1) def test_context_define_invalid_for_write_due_to_modifier(self): """Test definition of a context that is not a valid write context.""" self.t.config("confirmation", "off") code, out, err = self.t('context define urgent due.before:today') self.assertIn("Context 'urgent' defined", out) # Assert the config contains read context definition context_line = 'context.urgent.read=due.before:today\n' self.assertIn(context_line, self.t.taskrc_content) # Assert that it contains the definition only once self.assertEqual(self.t.taskrc_content.count(context_line), 1) # Assert the config does not contain write context definition context_line = 'context.urgent.write=due.before:today\n' self.assertNotIn(context_line, self.t.taskrc_content) # Assert that the write context was not set at all self.assertNotIn('context.urgent.write=', self.t.taskrc_content) # Assert that legacy style was not used # Assert the config contains read context definition context_line = 'context.urgent=due.before:today\n' self.assertNotIn(context_line, self.t.taskrc_content) def test_context_define_invalid_for_write_due_to_operator(self): """Test definition of a context that is not a valid write context because it uses an OR operator.""" self.t.config("confirmation", "off") code, out, err = self.t('context define urgent due:today or +next') self.assertIn("Context 'urgent' defined", out) # Assert the config contains read context definition context_line = 'context.urgent.read=due:today or +next\n' self.assertIn(context_line, self.t.taskrc_content) # Assert that it contains the definition only once self.assertEqual(self.t.taskrc_content.count(context_line), 1) # Assert the config does not contain write context definition context_line = 'context.urgent.write=due:today or +next\n' self.assertNotIn(context_line, self.t.taskrc_content) # Assert that the write context was not set at all self.assertNotIn('context.urgent.write=', self.t.taskrc_content) # Assert that legacy style was not used # Assert the config contains read context definition context_line = 'context.urgent=due:today or +next\n' self.assertNotIn(context_line, self.t.taskrc_content) def test_context_define_invalid_for_write_due_to_tag_exclusion(self): """Test definition of a context that is not a valid write context because it contains a tag exclusion.""" self.t.config("confirmation", "off") code, out, err = self.t('context define nowork due:today -work') self.assertIn("Context 'nowork' defined", out) # Assert the config contains read context definition context_line = 'context.nowork.read=due:today -work\n' self.assertIn(context_line, self.t.taskrc_content) # Assert that it contains the definition only once self.assertEqual(self.t.taskrc_content.count(context_line), 1) # Assert the config does not contain write context definition context_line = 'context.nowork.write=due:today -work\n' self.assertNotIn(context_line, self.t.taskrc_content) # Assert that the write context was not set at all self.assertNotIn('context.nowork.write=', self.t.taskrc_content) # Assert that legacy style was not used # Assert the config contains read context definition context_line = 'context.nowork=due:today -work\n' self.assertNotIn(context_line, self.t.taskrc_content) def test_context_delete(self): """Test simple context deletion.""" self.t('context define work project:Work', input='y\ny\n') code, out, err = self.t('context delete work', input='y\ny\n') self.assertIn("Context 'work' deleted.", out) # Assert that taskrc does not countain context work definition self.assertFalse(any('context.work' in line for line in self.t.taskrc_content)) def test_context_delete_undefined(self): """Test deletion of undefined context.""" code, out, err = self.t.runError('context delete foo', input='y\n') self.assertIn("Context 'foo' not found.", err) # Assert that taskrc does not countain context work definition self.assertFalse(any('context.foo.read=' in line for line in self.t.taskrc_content)) self.assertFalse(any('context.foo.write=' in line for line in self.t.taskrc_content)) def test_context_delete_unset_after_removal(self): """Test that context is unset if its definition has been removed.""" self.t('context define work project:Work', input='y\ny\n') self.t('context work') code, out, err = self.t('context delete work', input='y\n\y\n') self.assertIn("Context 'work' deleted.", out) # Assert that taskrc does not countain context work definition self.assertFalse(any('context.work=' in line for line in self.t.taskrc_content)) self.assertFalse(any('context.work.read=' in line for line in self.t.taskrc_content)) self.assertFalse(any('context.work.write=' in line for line in self.t.taskrc_content)) # Aseert that the context is not set code, out, err = self.t('context show') self.assertIn('No context is currently applied.', out) self.assertFalse(any(re.search(r"^context(\.(read|write))?=", line) for line in self.t.taskrc_content)) def test_context_list_active(self): """Test the 'context list' command.""" self.t('context define work project:Work', input='y\ny\n') self.t('context define home +home', input='y\ny\n') self.t('context home') code, out, err = self.t('context list') contains_work = lambda line: 'work' in line and 'project:Work' in line and 'no' in line contains_home = lambda line: 'home' in line and '+home' in line and 'yes' in line # Assert that output contains work and home context definitions exactly # once self.assertEqual(len(list(filter(contains_work, out.splitlines()))), 1) self.assertEqual(len(list(filter(contains_home, out.splitlines()))), 1) def test_context_list_legacy(self): """Test the determination of legacy context definition.""" self.t('config context.old project:Old', input='y\n') self.t('context old') code, out, err = self.t('context list') # Assert that "old" context has only the read component defined self.assertRegex(out, r'read\s+project:Old\s+yes') self.assertRegex(out, r'write\s+yes') def test_context_initially_empty(self): """Test that no context is set initially.""" self.t('context define work project:Work', input='y\ny\n') self.t('context define home +home', input='y\ny\n') code, out, err = self.t('context show') self.assertIn('No context is currently applied.', out) self.assertFalse(any(re.search("^context=", line) for line in self.t.taskrc_content)) def test_context_setting(self): """Test simple context setting.""" self.t('context define work project:Work', input='y\ny\n') self.t('context define home home', input='y\ny\n') code, out, err = self.t('context home') self.assertIn("Context 'home' set.", out) self.assertIn("context=home\n", self.t.taskrc_content) def test_context_resetting(self): """Test resetting the same context.""" self.t('context define work project:Work', input='y\ny\n') self.t('context define home +home', input='y\ny\n') self.t('context home') code, out, err = self.t('context home') self.assertIn("Context 'home' set.", out) context_line = "context=home\n" self.assertEqual(self.t.taskrc_content.count(context_line), 1) def test_context_switching(self): """Test changing the context.""" self.t('context define work project:Work', input='y\ny\n') self.t('context define home +home', input='y\ny\n') # Switch to home context code, out, err = self.t('context home') self.assertIn("Context 'home' set.", out) self.assertEqual(self.t.taskrc_content.count("context=home\n"), 1) # Switch to work context code, out, err = self.t('context work') self.assertIn("Context 'work' set.", out) self.assertNotIn("context=home\n", self.t.taskrc_content) self.assertEqual(self.t.taskrc_content.count("context=work\n"), 1) # Switch back to home context code, out, err = self.t('context home') self.assertIn("Context 'home' set.", out) self.assertNotIn("context=work\n", self.t.taskrc_content) self.assertEqual(self.t.taskrc_content.count("context=home\n"), 1) def test_context_unsetting(self): """Test removing the context.""" self.t('context define work project:Work', input='y\ny\n') self.t('context define home +home', input='y\ny\n') self.t('context home') code, out, err = self.t('context none') # Assert expected output. self.assertIn("Context unset.", out) # Assert no context definition in the taskrc contains_any_context = lambda line: re.match('^context=', line) self.assertFalse(any(contains_any_context(line) for line in self.t.taskrc_content)) # Assert no context showing up using show subcommand code, out, err = self.t('context show') self.assertIn("No context is currently applied.", out) def test_context_unsetting_after_switching(self): """Test unsetting the context after changing the context around.""" self.t('context define work project:Work', input='y\ny\n') self.t('context define home +home', input='y\ny\n') # Switch to contexts around self.t('context home') self.t('context work') self.t('context home') # Unset the context code, out, err = self.t('context none') # Assert expected output. self.assertIn("Context unset.", out) # Assert no context definition in the taskrc contains_any_context = lambda line: re.match('^context=', line) self.assertFalse(any(contains_any_context(line) for line in self.t.taskrc_content)) # Assert no context showing up using show subcommand code, out, err = self.t('context show') self.assertIn("No context is currently applied.", out) def test_context_unsetting_with_no_context_set(self): """Test removing the context when no context is set.""" self.t('context define work project:Work', input='y\ny\n') self.t('context define home +home', input='y\ny\n') code, out, err = self.t.runError('context none') # Assert expected output. self.assertIn("Context not unset.", err) # Assert no context definition in the taskrc contains_any_context = lambda line: re.match('^context=', line) self.assertFalse(any(contains_any_context(line) for line in self.t.taskrc_content)) # Assert no context showing up using show subcommand code, out, err = self.t('context show') self.assertIn("No context is currently applied.", out) def test_context(self): """Test the _context command.""" self.t('context define work project:Work', input='y\ny\n') self.t('context define home +home', input='y\ny\n') code, out, err = self.t('_context') # Assert expected output. self.assertIn("work", out.splitlines()) self.assertIn("home", out.splitlines()) self.assertEqual(len(out.splitlines()), 2) def test_context_completion(self): """Test the _context command with some context set.""" self.t('context define work project:Work', input='y\ny\n') self.t('context define home +home', input='y\ny\n') # Activate some context self.t('context work') code, out, err = self.t('_context') # Assert expected output. self.assertIn("work", out.splitlines()) self.assertIn("home", out.splitlines()) self.assertEqual(len(out.splitlines()), 2) class ContextEvaluationTest(TestCase): def setUp(self): self.t = Task() self.t.config("confirmation", "off") # Setup contexts self.t('context define work project:Work') self.t('context define home +home') self.t('context define today due:today') # Setup tasks self.t('add project:Work "work task"') self.t('add +home "home task"') self.t('add project:Work due:today "work today task"') self.t('add +home due:today "home today task"') def test_context_evaluation(self): """Test the context applied with report list command.""" code, out, err = self.t('list') # Assert all the tasks are present in the output self.assertIn("work task", out) self.assertIn("home task", out) self.assertIn("work today task", out) self.assertIn("home today task", out) # Set the home context and rerun the report self.t('context home') code, out, err = self.t('list') # Assert all the tasks with the home tag are present in the output self.assertNotIn("work task", out) self.assertIn("home task", out) self.assertNotIn("work today task", out) self.assertIn("home today task", out) def test_context_evaluation_switching(self): """Test swtiching context using the list report.""" code, out, err = self.t('list') # Assert all the tasks are present in the output self.assertIn("work task", out) self.assertIn("home task", out) self.assertIn("work today task", out) self.assertIn("home today task", out) # Set the home context and rerun the report self.t('context home') code, out, err = self.t('list') # Assert all the tasks with the home tag are present in the output self.assertNotIn("work task", out) self.assertIn("home task", out) self.assertNotIn("work today task", out) self.assertIn("home today task", out) # Set the work context and rerun the report self.t('context work') code, out, err = self.t('list') # Assert all the tasks with the home tag are present in the output self.assertIn("work task", out) self.assertNotIn("home task", out) self.assertIn("work today task", out) self.assertNotIn("home today task", out) # Set the today context and rerun the report self.t('context today') code, out, err = self.t('list') # Assert all the tasks with the home tag are present in the output self.assertNotIn("work task", out) self.assertNotIn("home task", out) self.assertIn("work today task", out) self.assertIn("home today task", out) def test_context_evaluation_unset(self): """Test unsetting context with report list command.""" self.t('context home') code, out, err = self.t('list') # Assert all the tasks home tagged tasks are present self.assertNotIn("work task", out) self.assertIn("home task", out) self.assertNotIn("work today task", out) self.assertIn("home today task", out) # Set the context to none self.t('context none') code, out, err = self.t('list') # Assert all the tasks are present in the output self.assertIn("work task", out) self.assertIn("home task", out) self.assertIn("work today task", out) self.assertIn("home today task", out) def test_context_evaluation_with_user_filters(self): """Test the context applied with report list command combined with user filters.""" # Set the home context self.t('context home') code, out, err = self.t('list due:today') # Assert all the tasks are present in the output self.assertNotIn("work task", out) self.assertNotIn("home task", out) self.assertNotIn("work today task", out) self.assertIn("home today task", out) # Set the work context and rerun the report self.t('context work') code, out, err = self.t('list due:today') # Assert all the tasks are present in the output self.assertNotIn("work task", out) self.assertNotIn("home task", out) self.assertIn("work today task", out) self.assertNotIn("home today task", out) def test_context_not_applied_on_id_filters(self): """ Test that context is not applied when explicit ID filters are used. """ self.t('context home') # Try task not included in context output = self.t('1 list')[1] # Assert that ID filter works even if it does not match the context self.assertIn("work task", output) self.assertNotIn("home task", output) self.assertNotIn("work today task", output) self.assertNotIn("home today task", output) # Try task included in context output = self.t('2 list')[1] # Assert that ID filter works if it does match # the context (sanity check) self.assertNotIn("work task", output) self.assertIn("home task", output) self.assertNotIn("work today task", output) self.assertNotIn("home today task", output) # Test for combination of IDs output = self.t('1 2 list')[1] # Assert that ID filter works if it partly matches # and partly does not match the context self.assertIn("work task", output) self.assertIn("home task", output) self.assertNotIn("work today task", output) self.assertNotIn("home today task", output) def test_context_not_applied_on_uuid_filters(self): """ Test that context is not applied when explicit UUID filters are used. """ self.t('context home') first_uuid = self.t('_get 1.uuid')[1] second_uuid = self.t('_get 2.uuid')[1] # Try task not included in context output = self.t('%s list' % first_uuid)[1] # Assert that UUID filter works even if it does not match # the context self.assertIn("work task", output) self.assertNotIn("home task", output) self.assertNotIn("work today task", output) self.assertNotIn("home today task", output) # Try task included in context output = self.t('%s list' % second_uuid)[1] # Assert that UUID filter works if it does match # the context (sanity check) self.assertNotIn("work task", output) self.assertIn("home task", output) self.assertNotIn("work today task", output) self.assertNotIn("home today task", output) # Test for combination of UUIDs output = self.t('%s %s list' % (first_uuid, second_uuid))[1] # Assert that UUID filter works if it partly matches # and partly does not match the context self.assertIn("work task", output) self.assertIn("home task", output) self.assertNotIn("work today task", output) self.assertNotIn("home today task", output) def test_context_ignored(self): """Test the context is not applied with report list command if report.list.context is set to 0.""" # Turn off context for this report self.t.config("report.list.context", "0") # Get the tasks code, out, err = self.t('list') # Assert all the tasks are present in the output self.assertIn("work task", out) self.assertIn("home task", out) self.assertIn("work today task", out) self.assertIn("home today task", out) # Set the home context and rerun the report self.t('context home') code, out, err = self.t('list') # Assert nothing changed - all the tasks are present in the output self.assertIn("work task", out) self.assertIn("home task", out) self.assertIn("work today task", out) self.assertIn("home today task", out) class ContextErrorHandling(TestCase): def setUp(self): self.t = Task() def test_list_empty(self): """Verify 'task context list' with no contexts yields error""" code, out, err = self.t.runError("context list") self.assertIn("No contexts defined.", err) def test_define_empty(self): """Verify 'task context define' with no contexts yields error""" code, out, err = self.t.runError("context define") self.assertIn("Both context name and its definition must be provided.", err) def test_delete_empty(self): """Verify 'task context delete' with no contexts yields error""" code, out, err = self.t.runError("context delete") self.assertIn("Context name needs to be specified.", err) def test_set_missing(self): """Verify 'task context missing' with no contexts yields error""" code, out, err = self.t.runError("context missing") self.assertIn("Context 'missing' not found.", err) def test_set_multi(self): """Verify 'task context one\\ two' with no contexts yields error""" code, out, err = self.t.runError("context one\\ two") self.assertIn("Context 'one two' not found.", err) def test_show_missing(self): """Verify 'task context show' with no contexts yields correct information""" code, out, err = self.t("context show") self.assertIn("No context is currently applied.", out) def test_show_present(self): """Verify 'task context show' with contexts works""" self.t.config("confirmation", "off") code, out, err = self.t("context define work +work") self.assertIn("Context 'work' defined (read, write). Use 'task context work' to activate.", out) code, out, err = self.t("context work") self.assertIn("Context 'work' set. Use 'task context none' to remove.", out) code, out, err = self.t("context show") self.assertIn("Context 'work' with", out) self.assertIn("read filter: '+work'", out) self.assertIn("write filter: '+work'", out) self.assertIn("is currently applied", out) code, out, err = self.t("context none") self.assertIn("Context unset.", out) code, out, err = self.t("context show") self.assertIn("No context is currently applied.", out) class TestBug1734(TestCase): def setUp(self): self.t = Task() self.t("add zero") self.t("add one +tag") self.t("context define foo +tag", input="y\nn\n") def test_calendar(self): """The 'calendar' command should not fail when a context is active""" code, out, err = self.t("calendar") # TODO Prove context does not interfere with export # TODO Prove context does not interfere with undo # TODO Prove context does not interfere with helper commands if __name__ == "__main__": from simpletap import TAPTestRunner unittest.main(testRunner=TAPTestRunner()) # vim: ai sts=4 et sw=4 ft=python syntax=python