class BugTestCase(unittest.TestCase):
def setUp(self):
db.connectDatabase("", memoryDatabase=True)
self.session = db.getSession()
setDefaultConfig()
tui.clearInputAnswers()
self.cmd = YokadiCmd()
def testAdd(self):
tui.addInputAnswers("y", "2", "4", "123")
self.cmd.do_bug_add("x t1")
tui.addInputAnswers("n")
self.cmd.do_bug_add("notExistingProject newBug")
tasks = self.session.query(Task).all()
result = [x.title for x in tasks]
expected = ["t1"]
self.assertEqual(result, expected)
kwDict = self.session.query(Task).get(1).getKeywordDict()
self.assertEqual(kwDict, dict(_severity=2, _likelihood=4, _bug=123))
for bad_input in ("", # No project
"x"): # No task name
self.assertRaises(YokadiException, self.cmd.do_bug_add, bad_input)
class ConfTestCase(unittest.TestCase):
def setUp(self):
db.connectDatabase("", memoryDatabase=True)
setDefaultConfig()
self.session = db.getSession()
tui.clearInputAnswers()
self.cmd = YokadiCmd()
def testConfig(self):
out = StringIO()
oldstdout = sys.stdout
tui.stdout = out
self.cmd.do_c_set("ALARM_DELAY 69")
self.cmd.do_c_get("ALARM_DELAY")
self.assertTrue("ALARM_DELAY" in out.getvalue())
self.assertTrue("69" in out.getvalue())
tui.stdout = oldstdout
def testPositiveValueConfig(self):
self.assertRaises(YokadiException, self.cmd.do_c_set, "ALARM_DELAY -1")
self.assertRaises(YokadiException, self.cmd.do_c_set,
"ALARM_SUSPEND -1")
self.assertRaises(YokadiException, self.cmd.do_c_set, "PURGE_DELAY -1")
def testWrongKey(self):
self.assertRaises(YokadiException, self.cmd.do_c_set, "BAD_KEY value")
self.assertRaises(YokadiException, self.cmd.do_c_get, "BAD_KEY")
class ConfTestCase(unittest.TestCase):
def setUp(self):
db.connectDatabase("", memoryDatabase=True)
setDefaultConfig()
self.session = db.getSession()
tui.clearInputAnswers()
self.cmd = YokadiCmd()
def testConfig(self):
out = StringIO()
oldstdout = sys.stdout
tui.stdout = out
self.cmd.do_c_set("ALARM_DELAY 69")
self.cmd.do_c_get("ALARM_DELAY")
self.assertTrue("ALARM_DELAY" in out.getvalue())
self.assertTrue("69" in out.getvalue())
tui.stdout = oldstdout
def testPositiveValueConfig(self):
self.assertRaises(YokadiException, self.cmd.do_c_set, "ALARM_DELAY -1")
self.assertRaises(YokadiException, self.cmd.do_c_set, "ALARM_SUSPEND -1")
self.assertRaises(YokadiException, self.cmd.do_c_set, "PURGE_DELAY -1")
def testWrongKey(self):
self.assertRaises(YokadiException, self.cmd.do_c_set, "BAD_KEY value")
self.assertRaises(YokadiException, self.cmd.do_c_get, "BAD_KEY")
class BugTestCase(unittest.TestCase):
def setUp(self):
testutils.clearDatabase()
tui.clearInputAnswers()
self.cmd = YokadiCmd()
def testAdd(self):
tui.addInputAnswers("y", "2", "4", "123")
self.cmd.do_bug_add("x t1")
tui.addInputAnswers("n")
self.cmd.do_bug_add("notExistingProject newBug")
tasks = list(Task.select())
result = [x.title for x in tasks]
expected = [u"t1"]
self.assertEqual(result, expected)
kwDict = Task.get(1).getKeywordDict()
self.assertEqual(kwDict, dict(_severity=2, _likelihood=4, _bug=123))
for bad_input in ("", # No project
"x"): # No task name
self.assertRaises(YokadiException, self.cmd.do_bug_add, bad_input)
def testHelp(self):
cmd = YokadiCmd()
for attr in dir(cmd):
if not attr.startswith("do_"):
continue
yokadiCommand = attr[3:]
try:
# Execute the command, but redirect stdout and stderr to
# /dev/null to avoid flooding the terminal
with to_devnull(sys.stdout), to_devnull(sys.stderr):
# We use Cmd implementation of onecmd() because YokadiCmd
# overrides it to catch exceptions
Cmd.onecmd(cmd, "help " + yokadiCommand)
except Exception:
print("'help %s' failed" % yokadiCommand)
raise
class BugTestCase(unittest.TestCase):
def setUp(self):
db.connectDatabase("", memoryDatabase=True)
self.session = db.getSession()
setDefaultConfig()
tui.clearInputAnswers()
self.cmd = YokadiCmd()
def testAdd(self):
tui.addInputAnswers("y", "2", "4", "123")
self.cmd.do_bug_add("x t1")
tui.addInputAnswers("n")
self.cmd.do_bug_add("notExistingProject newBug")
tasks = self.session.query(Task).all()
result = [x.title for x in tasks]
expected = ["t1"]
self.assertEqual(result, expected)
kwDict = self.session.query(Task).get(1).getKeywordDict()
self.assertEqual(kwDict, dict(_severity=2, _likelihood=4, _bug=123))
for bad_input in (
"", # No project
"x"): # No task name
self.assertRaises(YokadiException, self.cmd.do_bug_add, bad_input)
def testEdit(self):
task = dbutils.addTask("prj", "bug", interactive=False)
kwDict = dict(_severity=1, _likelihood=2, _bug=3)
task.setKeywordDict(kwDict)
self.session.commit()
tui.addInputAnswers("bug edited", "2", "4", "6")
self.cmd.do_bug_edit(str(task.id))
task = dbutils.getTaskFromId(task.id)
self.assertEqual(task.title, "bug edited")
kwDict = task.getKeywordDict()
self.assertEqual(kwDict, dict(_severity=2, _likelihood=4, _bug=6))
class BugTestCase(unittest.TestCase):
def setUp(self):
db.connectDatabase("", memoryDatabase=True)
self.session = db.getSession()
setDefaultConfig()
tui.clearInputAnswers()
self.cmd = YokadiCmd()
def testAdd(self):
tui.addInputAnswers("y", "2", "4", "123")
self.cmd.do_bug_add("x t1")
tui.addInputAnswers("n")
self.cmd.do_bug_add("notExistingProject newBug")
tasks = self.session.query(Task).all()
result = [x.title for x in tasks]
expected = ["t1"]
self.assertEqual(result, expected)
kwDict = self.session.query(Task).get(1).getKeywordDict()
self.assertEqual(kwDict, dict(_severity=2, _likelihood=4, _bug=123))
for bad_input in ("", # No project
"x"): # No task name
self.assertRaises(YokadiException, self.cmd.do_bug_add, bad_input)
def testEdit(self):
task = dbutils.addTask("prj", "bug", interactive=False)
kwDict = dict(_severity=1, _likelihood=2, _bug=3)
task.setKeywordDict(kwDict)
self.session.commit()
tui.addInputAnswers("bug edited", "2", "4", "6")
self.cmd.do_bug_edit(str(task.id))
task = dbutils.getTaskFromId(task.id)
self.assertEqual(task.title, "bug edited")
kwDict = task.getKeywordDict()
self.assertEqual(kwDict, dict(_severity=2, _likelihood=4, _bug=6))
def setUp(self):
db.connectDatabase("", memoryDatabase=True)
self.session = db.getSession()
setDefaultConfig()
tui.clearInputAnswers()
self.cmd = YokadiCmd()
class ProjectTestCase(unittest.TestCase):
def setUp(self):
db.connectDatabase("", memoryDatabase=True)
self.session = db.getSession()
tui.clearInputAnswers()
self.cmd = YokadiCmd()
def testAdd(self):
tui.addInputAnswers("y")
self.cmd.do_p_add("p1")
tui.addInputAnswers("y", "y")
self.cmd.do_p_add("p2 @kw1 @kw2=12")
projects = self.session.query(Project).all()
result = [x.name for x in projects]
expected = ["p1", "p2"]
self.assertEqual(result, expected)
kwDict = self.session.query(Project).filter_by(id=2).one().getKeywordDict()
self.assertEqual(kwDict, dict(kw1=None, kw2=12))
def testEdit(self):
# Create project p1 and rename it to p2
self.cmd.do_p_add("p1")
project = self.session.query(Project).filter_by(id=1).one()
self.assertEqual(project.name, "p1")
tui.addInputAnswers("p2")
self.cmd.do_p_edit("p1")
self.assertEqual(project.name, "p2")
# Create project p3 and try to rename it to p2
self.cmd.do_p_add("p3")
project = self.session.query(Project).filter_by(name="p3").one()
self.assertEqual(project.name, "p3")
tui.addInputAnswers("p2")
self.assertRaises(YokadiException, self.cmd.do_p_edit, "p3")
self.assertEqual(project.name, "p3")
def testRemove(self):
# Create project p1, with one project keyword and one associated task
tui.addInputAnswers("y")
self.cmd.do_p_add("p1 @kw")
project = self.session.query(Project).one()
task = dbutils.addTask("p1", "t1", interactive=False)
taskId = task.id
keyword = self.session.query(Keyword).filter_by(name="kw").one()
self.assertEqual(keyword.projects, [project])
# Remove project, its task should be removed and the created keyword
# should no longer be associated with any project
tui.addInputAnswers("y")
self.cmd.do_p_remove("p1")
self.assertEqual(keyword.projects, [])
self.assertEqual(list(self.session.query(Task).filter_by(id=taskId)), [])
def testStatus(self):
# Create project p1 and test set active and set inactive method
self.cmd.do_p_add("p1")
project = self.session.query(Project).filter_by(id=1).one()
self.assertEqual(project.name, "p1")
self.assertEqual(project.active, True)
self.cmd.do_p_set_inactive("p1")
self.assertEqual(project.active, False)
self.cmd.do_p_set_active("p1")
self.assertEqual(project.active, True)
class ProjectTestCase(unittest.TestCase):
def setUp(self):
db.connectDatabase("", memoryDatabase=True)
self.session = db.getSession()
tui.clearInputAnswers()
self.cmd = YokadiCmd()
def testAdd(self):
tui.addInputAnswers("y")
self.cmd.do_p_add("p1")
self.cmd.do_p_add("p2")
projects = self.session.query(Project).all()
result = [x.name for x in projects]
expected = ["p1", "p2"]
self.assertEqual(result, expected)
def testEdit(self):
# Create project p1 and rename it to p2
self.cmd.do_p_add("p1")
project = self.session.query(Project).filter_by(id=1).one()
self.assertEqual(project.name, "p1")
tui.addInputAnswers("p2")
self.cmd.do_p_edit("p1")
self.assertEqual(project.name, "p2")
# Create project p3 and try to rename it to p2
self.cmd.do_p_add("p3")
project = self.session.query(Project).filter_by(name="p3").one()
self.assertEqual(project.name, "p3")
tui.addInputAnswers("p2")
self.assertRaises(YokadiException, self.cmd.do_p_edit, "p3")
self.assertEqual(project.name, "p3")
def testRemove(self):
# Create project p1 with one associated task
tui.addInputAnswers("y")
self.cmd.do_p_add("p1")
self.session.query(Project).one()
task = dbutils.addTask("p1", "t1", interactive=False)
taskId = task.id
# Remove project, its task should be removed
tui.addInputAnswers("y")
self.cmd.do_p_remove("p1")
self.assertEqual(list(self.session.query(Task).filter_by(id=taskId)), [])
def testStatus(self):
# Create project p1 and test set active and set inactive method
self.cmd.do_p_add("p1")
project = self.session.query(Project).filter_by(id=1).one()
self.assertEqual(project.name, "p1")
self.assertEqual(project.active, True)
self.cmd.do_p_set_inactive("p1")
self.assertEqual(project.active, False)
self.cmd.do_p_set_active("p1")
self.assertEqual(project.active, True)
def testMerge(self):
COUNT = 4
for x in range(COUNT):
dbutils.addTask('p1', 'p1-t{}'.format(x), interactive=False)
dbutils.addTask('p2', 'p2-t{}'.format(x), interactive=False)
# Merge p1 into p2
tui.addInputAnswers("y")
self.cmd.do_p_merge("p1 p2")
# p2 should have both its tasks and all p1 tasks now
project = self.session.query(Project).filter_by(name="p2").one()
tasks = set([x.title for x in project.tasks])
expected = set()
for x in range(COUNT):
expected.add('p1-t{}'.format(x))
expected.add('p2-t{}'.format(x))
self.assertEqual(tasks, expected)
# p1 should be gone
testutils.assertQueryEmpty(self, self.session.query(Project).filter_by(name="p1"))
def testMergeItselfFails(self):
project = Project(name="p1")
self.assertRaises(YokadiException, project.merge, self.session, project)
def setUp(self):
db.connectDatabase("", memoryDatabase=True)
setDefaultConfig()
self.session = db.getSession()
tui.clearInputAnswers()
self.cmd = YokadiCmd()
class TaskTestCase(unittest.TestCase):
def setUp(self):
db.connectDatabase("", memoryDatabase=True)
setDefaultConfig()
self.session = db.getSession()
tui.clearInputAnswers()
self.cmd = YokadiCmd()
def testAdd(self):
tui.addInputAnswers("y")
self.cmd.do_t_add("x t1")
tui.addInputAnswers("y", "y")
self.cmd.do_t_add("x @kw1 @kw2=12 t2")
tui.addInputAnswers("n")
self.cmd.do_t_add("notExistingProject newTask")
tasks = self.session.query(Task).all()
result = [x.title for x in tasks]
expected = ["t1", "t2"]
self.assertEqual(result, expected)
kwDict = self.session.query(Task).get(2).getKeywordDict()
self.assertEqual(kwDict, dict(kw1=None, kw2=12))
for bad_input in ("", # No project
"x"): # No task name
self.assertRaises(BadUsageException, self.cmd.do_t_add, bad_input)
# Crypto stuff
tui.addInputAnswers("a Secret passphrase")
self.cmd.do_t_add("-c x encrypted t1")
self.assertTrue(self.session.query(Task).get(3).title.startswith(cryptutils.CRYPTO_PREFIX))
def testEdit(self):
tui.addInputAnswers("y")
self.cmd.do_t_add("x txt @_note")
tui.addInputAnswers("newtxt")
self.cmd.do_t_edit("1")
task = self.session.query(Task).get(1)
self.assertEqual(task.title, "newtxt")
self.assertEqual(task.getKeywordDict(), {"_note": None})
def testEditAddKeyword(self):
tui.addInputAnswers("y")
self.cmd.do_t_add("x txt")
tui.addInputAnswers("txt @kw", "y")
self.cmd.do_t_edit("1")
task = self.session.query(Task).get(1)
self.assertEqual(task.title, "txt")
self.assertEqual(task.getKeywordDict(), {"kw": None})
def testEditRemoveKeyword(self):
tui.addInputAnswers("y", "y")
self.cmd.do_t_add("x txt @kw")
tui.addInputAnswers("txt")
self.cmd.do_t_edit("1")
task = self.session.query(Task).get(1)
self.assertEqual(task.title, "txt")
self.assertEqual(task.getKeywordDict(), {})
def testRemove(self):
# Create a recurrent task with one keyword
tui.addInputAnswers("y", "y")
self.cmd.do_t_add("x @kw bla")
task = self.session.query(Task).one()
self.cmd.do_t_recurs("1 daily 10:00")
keyword = self.session.query(Keyword).filter_by(name="kw").one()
self.assertEqual(keyword.tasks, [task])
# Pretend we edit the task description so that we have a TaskLock for
# this task
taskLockManager = dbutils.TaskLockManager(task)
taskLockManager.acquire()
self.session.query(TaskLock).one()
self.assertEqual(self.session.query(TaskLock).count(), 1)
# Remove it, the keyword should no longer be associated with any task,
# the lock should be gone
tui.addInputAnswers("y")
self.cmd.do_t_remove(str(task.id))
self.assertEqual(keyword.tasks, [])
self.assertEqual(self.session.query(TaskLock).count(), 0)
# Should not crash
taskLockManager.release()
def testMark(self):
tui.addInputAnswers("y")
self.cmd.do_t_add("x t1")
task = self.session.query(Task).get(1)
self.assertEqual(task.status, "new")
self.cmd.do_t_mark_started("1")
self.assertEqual(task.status, "started")
self.cmd.do_t_mark_new("1")
self.assertEqual(task.status, "new")
self.cmd.do_t_mark_done("1")
self.assertEqual(task.status, "done")
def testAddKeywords(self):
tui.addInputAnswers("y")
self.cmd.do_t_add("x t1")
task = self.session.query(Task).get(1)
tui.addInputAnswers("y", "y")
self.cmd.do_t_add_keywords("1 @kw1 @kw2=12")
kwDict = task.getKeywordDict()
self.assertEqual(kwDict, dict(kw1=None, kw2=12))
for bad_input in ("", # No task
"1", # No keyword
"1 kw1"): # No @ before kw1
self.assertRaises(YokadiException, self.cmd.do_t_add_keywords, bad_input)
def testSetProject(self):
tui.addInputAnswers("y")
self.cmd.do_t_add("x t1")
tui.addInputAnswers("y")
self.cmd.do_t_project("1 y")
task1 = self.session.query(Task).get(1)
self.assertEqual(task1.project.name, "y")
self.cmd.do_t_add("x t2")
self.cmd.do_t_project("1 _")
task1 = self.session.query(Task).get(1)
self.assertEqual(task1.project.name, "x")
tui.addInputAnswers("n")
self.cmd.do_t_project("1 doesnotexist")
task1 = self.session.query(Task).get(1)
self.assertEqual(task1.project.name, "x")
def testLastTaskId(self):
# Using "_" with no prior task activity should raise an exception
self.assertRaises(YokadiException, self.cmd.getTaskFromId, "_")
tui.addInputAnswers("y")
self.cmd.do_t_add("x t1")
task1 = self.session.query(Task).get(1)
self.assertEqual(self.cmd.getTaskFromId("_"), task1)
self.cmd.do_t_add("x t2")
task2 = self.session.query(Task).get(2)
self.assertEqual(self.cmd.getTaskFromId("_"), task2)
self.cmd.do_t_mark_started("1")
self.assertEqual(self.cmd.getTaskFromId("_"), task1)
def testLastProjectName(self):
# Using "_" with no prior project used should raise an exception
self.assertRaises(YokadiException, self.cmd.do_t_add, "_ t1")
tui.addInputAnswers("y")
self.cmd.do_t_add("x t1")
task1 = self.session.query(Task).get(1)
self.cmd.do_t_add("_ t2")
task2 = self.session.query(Task).get(2)
self.assertEqual(task1.project, task2.project)
def testRecurs(self):
tui.addInputAnswers("y")
self.cmd.do_t_add("x t1")
task = self.session.query(Task).get(1)
self.cmd.do_t_recurs("1 daily 10:00")
self.assertTrue(task.recurrence)
self.assertEqual(task.status, "new")
self.cmd.do_t_mark_done("1")
self.assertEqual(task.status, "new")
self.cmd.do_t_recurs("1 none")
self.assertFalse(task.recurrence)
self.cmd.do_t_mark_done("1")
self.assertEqual(task.status, "done")
for bad_input in ("", # No task
"1", # No recurence
"1 foo", # Unknown recurrence
"1 daily", # No time
"1 weekly", # No day
"1 weekly monday", # No time
"1 monthly", # No day
"1 monthly 10", # No time
"1 quarterly", # No day
"1 quarterly 10", # No time
"1 monthly foo 12:00", # Bad date
):
self.assertRaises(YokadiException, self.cmd.do_t_recurs, bad_input)
def testRenderListSectionOrder(self):
projectNames = "ccc", "aaa", "UPPER_CASE", "zzz", "mmm"
projectList = []
for name in projectNames:
prj = Project(name=name)
task = Task(project=prj, title="Hello")
self.session.add(prj)
self.session.add(task)
projectList.append(prj)
self.session.flush()
renderer = testutils.TestRenderer()
self.cmd._renderList(renderer, projectList, filters=[], order=[])
self.assertEqual(list(renderer.taskDict.keys()), sorted(projectNames, key=lambda x: x.lower()))
def testRenderListSectionOrderKeywords(self):
prj = Project(name="prj")
keywordNames = ["kw_" + x for x in ("ccc", "aaa", "UPPER_CASE", "zzz", "mmm")]
keywordList = []
for name in keywordNames:
keyword = Keyword(name=name)
task = Task(project=prj, title="Hello")
TaskKeyword(task=task, keyword=keyword)
self.session.add(task)
keywordList.append(prj)
self.session.flush()
renderer = testutils.TestRenderer()
self.cmd._renderList(renderer, [prj], filters=[], order=[], groupKeyword="kw_%")
self.assertEqual(list(renderer.taskDict.keys()), sorted(keywordNames, key=lambda x: x.lower()))
def testTlist(self):
tui.addInputAnswers("y")
self.cmd.do_t_add("x t1")
tui.addInputAnswers("y", "y")
self.cmd.do_t_add("x @kw1 @kw2=12 t2")
for line in ("", "-a", "-t", "-d today", "-u 10", "-k %", "-k _%", "-s t", "--overdue",
"@%", "@k%", "!@%", "!@kw1", "-f plain", "-f xml", "-f html", "-f csv"):
self.cmd.do_t_list(line)
def testNlist(self):
tui.addInputAnswers("y")
self.cmd.do_n_add("x t1")
self.cmd.do_t_add("x t2")
tui.addInputAnswers("y", "y")
self.cmd.do_n_add("x @kw1 @kw2=12 t3")
self.cmd.do_t_add("x @kw1 @kw2=12 t4")
for line in ("", "-k %", "-k _%", "-s t",
"@%", "@k%", "!@%", "!@kw1", "-f plain"):
self.cmd.do_t_list(line)
def testTfilter(self):
t1 = dbutils.addTask("x", "t1", interactive=False)
t2 = dbutils.addTask("x", "t2", keywordDict={"kw1": None, "kw2": 12}, interactive=False)
t3 = dbutils.addTask("y", "t3", interactive=False)
testData = [
("@kw1", {"x": [t2]}),
("@kw1 @kw2", {"x": [t2]}),
("x", {"x": [t1, t2]}),
("x @kw1", {"x": [t2]}),
("none", {"x": [t1, t2], "y": [t3]}),
]
for filter, expectedTaskDict in testData:
self.cmd.do_t_filter(filter)
renderer = testutils.TestRenderer()
self.cmd.do_t_list("", renderer=renderer)
self.assertEqual(renderer.taskDict.keys(), expectedTaskDict.keys())
for key in renderer.taskDict.keys():
self.assertEqual([x.title for x in renderer.taskDict[key]], [x.title for x in expectedTaskDict[key]])
self.assertRaises(YokadiException, self.cmd.do_t_filter, "")
def testTApply(self):
self.cmd.do_k_add("lala")
for i in range(10):
tui.addInputAnswers("y")
self.cmd.do_t_add("x t%s" % i)
ids = [1, 2, 4, 5, 6, 9]
self.cmd.do_t_apply("1 2,4-6 9 t_add_keywords @lala")
for taskId in range(1, 10):
kwDict = self.session.query(Task).get(taskId).getKeywordDict()
if taskId in ids:
self.assertEqual(kwDict, dict(lala=None))
else:
self.assertNotEqual(kwDict, dict(lala=None))
# raise error if t_list had not been called previously
self.assertRaises(BadUsageException, self.cmd.do_t_apply, "__ t_add_keywords @toto")
self.cmd.do_t_list("@lala")
self.cmd.do_t_apply("__ t_add_keywords @toto")
for taskId in range(1, 10):
kwDict = self.session.query(Task).get(taskId).getKeywordDict()
if taskId in ids:
self.assertEqual(kwDict, dict(lala=None, toto=None))
else:
self.assertNotEqual(kwDict, dict(lala=None, toto=None))
def testReorder(self):
self.assertRaises(BadUsageException, self.cmd.do_t_reorder, "unknown_project")
self.assertRaises(BadUsageException, self.cmd.do_t_reorder, "too much args")
def testDue(self):
tui.addInputAnswers("y")
self.cmd.do_t_add("x t1")
for valid_input in ("+1d", "+1m"):
self.cmd.do_t_due("1 %s" % valid_input)
for bad_input in ("coucou", "+1s"):
self.assertRaises(YokadiException, self.cmd.do_t_due, "1 %s" % bad_input)
class ProjectTestCase(unittest.TestCase):
def setUp(self):
db.connectDatabase("", memoryDatabase=True)
self.session = db.getSession()
tui.clearInputAnswers()
self.cmd = YokadiCmd()
def testAdd(self):
tui.addInputAnswers("y")
self.cmd.do_p_add("p1")
self.cmd.do_p_add("p2")
projects = self.session.query(Project).all()
result = [x.name for x in projects]
expected = ["p1", "p2"]
self.assertEqual(result, expected)
def testEdit(self):
# Create project p1 and rename it to p2
self.cmd.do_p_add("p1")
project = self.session.query(Project).filter_by(id=1).one()
self.assertEqual(project.name, "p1")
tui.addInputAnswers("p2")
self.cmd.do_p_edit("p1")
self.assertEqual(project.name, "p2")
# Create project p3 and try to rename it to p2
self.cmd.do_p_add("p3")
project = self.session.query(Project).filter_by(name="p3").one()
self.assertEqual(project.name, "p3")
tui.addInputAnswers("p2")
self.assertRaises(YokadiException, self.cmd.do_p_edit, "p3")
self.assertEqual(project.name, "p3")
def testRemove(self):
# Create project p1 with one associated task
tui.addInputAnswers("y")
self.cmd.do_p_add("p1")
project = self.session.query(Project).one()
task = dbutils.addTask("p1", "t1", interactive=False)
taskId = task.id
# Remove project, its task should be removed
tui.addInputAnswers("y")
self.cmd.do_p_remove("p1")
self.assertEqual(list(self.session.query(Task).filter_by(id=taskId)),
[])
def testStatus(self):
# Create project p1 and test set active and set inactive method
self.cmd.do_p_add("p1")
project = self.session.query(Project).filter_by(id=1).one()
self.assertEqual(project.name, "p1")
self.assertEqual(project.active, True)
self.cmd.do_p_set_inactive("p1")
self.assertEqual(project.active, False)
self.cmd.do_p_set_active("p1")
self.assertEqual(project.active, True)
def setUp(self):
testutils.clearDatabase()
tui.clearInputAnswers()
self.cmd = YokadiCmd()
class TaskTestCase(unittest.TestCase):
def setUp(self):
testutils.clearDatabase()
tui.clearInputAnswers()
self.cmd = YokadiCmd()
def testAdd(self):
tui.addInputAnswers("y")
self.cmd.do_t_add("x t1")
tui.addInputAnswers("y", "y")
self.cmd.do_t_add("x @kw1 @kw2=12 t2")
tui.addInputAnswers("n")
self.cmd.do_t_add("notExistingProject newTask")
tasks = list(Task.select())
result = [x.title for x in tasks]
expected = [u"t1", u"t2"]
self.assertEqual(result, expected)
kwDict = Task.get(2).getKeywordDict()
self.assertEqual(kwDict, dict(kw1=None, kw2=12))
for bad_input in ("", # No project
"x"): # No task name
self.assertRaises(BadUsageException, self.cmd.do_t_add, bad_input)
# Crypto stuff
tui.addInputAnswers("a Secret passphrase")
self.cmd.do_t_add("-c x encrypted t1")
self.assertTrue(Task.get(3).title.startswith(cryptutils.CRYPTO_PREFIX))
def testMark(self):
tui.addInputAnswers("y")
self.cmd.do_t_add("x t1")
task = Task.get(1)
self.assertEqual(task.status, "new")
self.cmd.do_t_mark_started("1")
self.assertEqual(task.status, "started")
self.cmd.do_t_mark_done("1")
self.assertEqual(task.status, "done")
def testAddKeywords(self):
tui.addInputAnswers("y")
self.cmd.do_t_add("x t1")
task = Task.get(1)
tui.addInputAnswers("y", "y")
self.cmd.do_t_add_keywords("1 @kw1 @kw2=12")
kwDict = task.getKeywordDict()
self.assertEqual(kwDict, dict(kw1=None, kw2=12))
for bad_input in ("", # No task
"1", # No keyword
"1 kw1"): # No @ before kw1
self.assertRaises(YokadiException, self.cmd.do_t_add_keywords, bad_input)
def testSetProject(self):
tui.addInputAnswers("y")
self.cmd.do_t_add("x t1")
tui.addInputAnswers("y")
self.cmd.do_t_project("1 y")
task1 = Task.get(1)
self.assertEqual(task1.project.name, "y")
self.cmd.do_t_add("x t2")
self.cmd.do_t_project("1 _")
task1 = Task.get(1)
self.assertEqual(task1.project.name, "x")
def testLastTaskId(self):
# Using "_" with no prior task activity should raise an exception
self.assertRaises(YokadiException, self.cmd.getTaskFromId, "_")
tui.addInputAnswers("y")
self.cmd.do_t_add("x t1")
task1 = Task.get(1)
self.assertEqual(self.cmd.getTaskFromId("_"), task1)
self.cmd.do_t_add("x t2")
task2 = Task.get(2)
self.assertEqual(self.cmd.getTaskFromId("_"), task2)
self.cmd.do_t_mark_started("1")
self.assertEqual(self.cmd.getTaskFromId("_"), task1)
def testLastProjectName(self):
# Using "_" with no prior project used should raise an exception
self.assertRaises(YokadiException, self.cmd.do_t_add, "_ t1")
tui.addInputAnswers("y")
self.cmd.do_t_add("x t1")
task1 = Task.get(1)
self.cmd.do_t_add("_ t2")
task2 = Task.get(2)
self.assertEqual(task1.project, task2.project)
def testRecurs(self):
tui.addInputAnswers("y")
self.cmd.do_t_add("x t1")
task = Task.get(1)
self.cmd.do_t_recurs("1 daily 10:00")
desc = str(task.recurrence)
self.cmd.do_t_recurs("1 weekly FR 23:00")
self.cmd.do_t_recurs("1 none")
self.cmd.do_t_recurs("1 weekly fr 23:00")
self.cmd.do_t_recurs("1 weekly Fr 23:00")
self.cmd.do_t_recurs("1 weekly Friday 23:00")
self.cmd.do_t_recurs("1 monthly 3 13:00")
self.cmd.do_t_recurs("1 monthly second friday 13:00")
self.cmd.do_t_recurs("1 yearly 3/07 11:20")
self.cmd.do_t_recurs("1 quarterly 14 11:20")
self.cmd.do_t_recurs("1 quarterly first monday 23:20")
self.assertNotEqual(desc, str(task.recurrence))
self.assertEqual(task.status, "new")
self.cmd.do_t_mark_done("1")
self.assertEqual(task.status, "new")
for bad_input in ("", # No task
"1", # No recurence
"1 foo", # Unknown recurrence
"1 daily", # No time
"1 weekly", # No day
"1 weekly monday", # No time
"1 monthly", # No day
"1 monthly 10", # No time
"1 quarterly", # No day
"1 quarterly 10", # No time
"1 monthly foo 12:00", # Bad date
):
self.assertRaises(YokadiException, self.cmd.do_t_recurs, bad_input)
def testTlist(self):
tui.addInputAnswers("y")
self.cmd.do_t_add("x t1")
tui.addInputAnswers("y", "y")
self.cmd.do_t_add("x @kw1 @kw2=12 t2")
for line in ("", "-a", "-t", "-d today", "-u 10", "-k %", "-k _%", "-s t", "--overdue",
"@%", "@k%", "!@%", "!@kw1", "-f plain", "-f xml", "-f html", "-f csv"):
self.cmd.do_t_list(line)
def testNlist(self):
tui.addInputAnswers("y")
self.cmd.do_n_add("x t1")
self.cmd.do_t_add("x t2")
tui.addInputAnswers("y", "y")
self.cmd.do_n_add("x @kw1 @kw2=12 t3")
self.cmd.do_t_add("x @kw1 @kw2=12 t4")
for line in ("", "-k %", "-k _%", "-s t",
"@%", "@k%", "!@%", "!@kw1", "-f plain"):
self.cmd.do_t_list(line)
def testTfilter(self):
tui.addInputAnswers("y")
self.cmd.do_t_add("x t1")
tui.addInputAnswers("y", "y")
self.cmd.do_t_add("x @kw1 @kw2=12 t2")
tui.addInputAnswers("y")
self.cmd.do_t_add("y t3")
for filter in ("@kw1", "x", "x @kw1", "none"):
self.cmd.do_t_filter(filter)
out = StringIO()
oldstdout = sys.stdout
tui.stdout = out
self.cmd.do_t_list("")
self.assertTrue("t2" in out.getvalue())
if filter in ("x", "none"):
self.assertTrue("t1" in out.getvalue())
else:
self.assertFalse("t1" in out.getvalue())
if filter == "none":
self.assertTrue("t3" in out.getvalue())
else:
self.assertFalse("t3" in out.getvalue())
tui.stdout = oldstdout
self.assertRaises(YokadiException, self.cmd.do_t_filter, "")
def testTApply(self):
self.cmd.do_k_add("lala")
for i in range(10):
tui.addInputAnswers("y")
self.cmd.do_t_add("x t%s" % i)
ids = [1, 2, 4, 5, 6, 9]
self.cmd.do_t_apply("1 2,4-6 9 t_add_keywords @lala")
for taskId in range(1, 10):
kwDict = Task.get(taskId).getKeywordDict()
if taskId in ids:
self.assertEqual(kwDict, dict(lala=None))
else:
self.assertNotEqual(kwDict, dict(lala=None))
# raise error if t_list had not been called previously
self.assertRaises(BadUsageException, self.cmd.do_t_apply, "__ t_add_keywords @toto")
self.cmd.do_t_list("@lala")
self.cmd.do_t_apply("__ t_add_keywords @toto")
for taskId in range(1, 10):
kwDict = Task.get(taskId).getKeywordDict()
if taskId in ids:
self.assertEqual(kwDict, dict(lala=None, toto=None))
else:
self.assertNotEqual(kwDict, dict(lala=None, toto=None))
class ProjectTestCase(unittest.TestCase):
def setUp(self):
db.connectDatabase("", memoryDatabase=True)
self.session = db.getSession()
tui.clearInputAnswers()
self.cmd = YokadiCmd()
def testAdd(self):
tui.addInputAnswers("y")
self.cmd.do_p_add("p1")
self.cmd.do_p_add("p2")
projects = self.session.query(Project).all()
result = [x.name for x in projects]
expected = ["p1", "p2"]
self.assertEqual(result, expected)
def testEdit(self):
# Create project p1 and rename it to p2
self.cmd.do_p_add("p1")
project = self.session.query(Project).filter_by(id=1).one()
self.assertEqual(project.name, "p1")
tui.addInputAnswers("p2")
self.cmd.do_p_edit("p1")
self.assertEqual(project.name, "p2")
# Create project p3 and try to rename it to p2
self.cmd.do_p_add("p3")
project = self.session.query(Project).filter_by(name="p3").one()
self.assertEqual(project.name, "p3")
tui.addInputAnswers("p2")
self.assertRaises(YokadiException, self.cmd.do_p_edit, "p3")
self.assertEqual(project.name, "p3")
def testRemove(self):
# Create project p1 with one associated task
tui.addInputAnswers("y")
self.cmd.do_p_add("p1")
self.session.query(Project).one()
task = dbutils.addTask("p1", "t1", interactive=False)
taskId = task.id
# Remove project, its task should be removed
tui.addInputAnswers("y")
self.cmd.do_p_remove("p1")
self.assertEqual(list(self.session.query(Task).filter_by(id=taskId)),
[])
def testStatus(self):
# Create project p1 and test set active and set inactive method
self.cmd.do_p_add("p1")
project = self.session.query(Project).filter_by(id=1).one()
self.assertEqual(project.name, "p1")
self.assertEqual(project.active, True)
self.cmd.do_p_set_inactive("p1")
self.assertEqual(project.active, False)
self.cmd.do_p_set_active("p1")
self.assertEqual(project.active, True)
def testMerge(self):
COUNT = 4
for x in range(COUNT):
dbutils.addTask('p1', 'p1-t{}'.format(x), interactive=False)
dbutils.addTask('p2', 'p2-t{}'.format(x), interactive=False)
# Merge p1 into p2
tui.addInputAnswers("y")
self.cmd.do_p_merge("p1 p2")
# p2 should have both its tasks and all p1 tasks now
project = self.session.query(Project).filter_by(name="p2").one()
tasks = set([x.title for x in project.tasks])
expected = set()
for x in range(COUNT):
expected.add('p1-t{}'.format(x))
expected.add('p2-t{}'.format(x))
self.assertEqual(tasks, expected)
# p1 should be gone
testutils.assertQueryEmpty(
self,
self.session.query(Project).filter_by(name="p1"))
def testMergeItselfFails(self):
project = Project(name="p1")
self.assertRaises(YokadiException, project.merge, self.session,
project)
