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 testTitleMapping(self):
tui.addInputAnswers("y")
t1 = dbutils.addTask("x", "t1", {})
v1 = yical.createVTodoFromTask(t1)
# Check id is here
self.assertEqual(v1.get("summary")[-4:], " (%s)" % t1.id)
# Title and id should not change with update
origin_id = t1.id
origin_title = t1.title
yical.updateTaskFromVTodo(t1, v1)
self.assertEqual(t1.id, origin_id)
self.assertEqual(t1.title, origin_title)
# Update vtodo summary and remove (id) or space before (id) info.
# Only task title should be changed
for new_summary in ("hello", "hello(%s)" % origin_id, "hello (%s)" % origin_id,
"(%s)hello" % origin_id, " (%s)hello" % origin_id):
v1["summary"] = new_summary
yical.updateTaskFromVTodo(t1, v1)
self.assertEqual(t1.id, origin_id)
self.assertEqual(t1.title, "hello")
# Update votod with fake id info.
# Should be present in task title
for new_summary in ("hello", "hello()", "hello(123456)", "hello (123456)"):
v1["summary"] = new_summary
yical.updateTaskFromVTodo(t1, v1)
self.assertEqual(t1.id, origin_id)
self.assertEqual(t1.title, new_summary)
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 testTitleMapping(self):
tui.addInputAnswers("y")
t1 = dbutils.addTask("x", "t1", {})
v1 = yical.createVTodoFromTask(t1)
# Check id is here
self.assertEqual(v1.get("summary")[-4:], " (%s)" % t1.id)
# Title and id should not change with update
origin_id = t1.id
origin_title = t1.title
yical.updateTaskFromVTodo(t1, v1)
self.assertEqual(t1.id, origin_id)
self.assertEqual(t1.title, origin_title)
# Update vtodo summary and remove (id) or space before (id) info.
# Only task title should be changed
for new_summary in ("hello", "hello(%s)" % origin_id,
"hello (%s)" % origin_id, "(%s)hello" % origin_id,
" (%s)hello" % origin_id):
v1["summary"] = new_summary
yical.updateTaskFromVTodo(t1, v1)
self.assertEqual(t1.id, origin_id)
self.assertEqual(t1.title, "hello")
# Update votod with fake id info.
# Should be present in task title
for new_summary in ("hello", "hello()", "hello(123456)",
"hello (123456)"):
v1["summary"] = new_summary
yical.updateTaskFromVTodo(t1, v1)
self.assertEqual(t1.id, origin_id)
self.assertEqual(t1.title, new_summary)
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 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 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)
def testRemove(self):
tui.addInputAnswers("y")
self.cmd.do_t_add("x t1")
self.assertEqual(self.session.query(Task).count(), 1)
tui.addInputAnswers("y")
self.cmd.do_t_remove("1")
self.assertEqual(self.session.query(Task).count(), 0)
def testEditCommand(self):
self.cmd.do_a_add("l t_list")
tui.addInputAnswers("foo")
self.cmd.do_a_edit_command("l")
aliases = Alias.getAsDict(self.session)
self.assertEqual(aliases["l"], "foo")
def testEditCommand(self):
self.cmd.do_a_add("l t_list")
tui.addInputAnswers("foo")
self.cmd.do_a_edit_command("l")
aliases = Alias.getAsDict(self.session)
self.assertEqual(aliases["l"], "foo")
def testEditName(self):
self.cmd.do_a_add("l t_list")
tui.addInputAnswers("ls")
self.cmd.do_a_edit_name("l")
aliases = Alias.getAsDict(self.session)
self.assertEqual(aliases["ls"], "t_list")
def testKEditNoMerge(self):
t1 = dbutils.addTask("x", "t1", dict(k1=12, k2=None), interactive=False)
tui.addInputAnswers("newk1")
self.cmd.do_k_edit("k1")
kwDict = t1.getKeywordDict()
self.assertTrue("k1" not in kwDict)
self.assertEqual(kwDict.get("newk1"), 12)
self.assertRaises(YokadiException, dbutils.getKeywordFromName, "k1")
def testConfirm(self):
tui.addInputAnswers("zog", "y")
value = tui.confirm("bla")
self.assertTrue(value)
tui.addInputAnswers("zog", "n")
value = tui.confirm("bla")
self.assertFalse(value)
def testEditName(self):
self.cmd.do_a_add("l t_list")
tui.addInputAnswers("ls")
self.cmd.do_a_edit_name("l")
aliases = Alias.getAsDict(self.session)
self.assertEqual(aliases["ls"], "t_list")
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 testGetOrCreateKeyword(self):
# interactive
tui.addInputAnswers("y")
dbutils.getOrCreateKeyword("k1")
self._assertOneObject(Keyword.selectBy(name="k1"))
# !interactive
dbutils.getOrCreateKeyword("k2", interactive=False)
self._assertOneObject(Keyword.selectBy(name="k2"))
def testGetOrCreateKeyword(self):
# interactive
tui.addInputAnswers("y")
dbutils.getOrCreateKeyword("k1")
self._assertOneObject(Keyword.selectBy(name="k1"))
# !interactive
dbutils.getOrCreateKeyword("k2", interactive=False)
self._assertOneObject(Keyword.selectBy(name="k2"))
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 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 testGetOrCreateProject(self):
# interactive
tui.addInputAnswers("y")
dbutils.getOrCreateProject("p1")
self._assertOneObject(Project.selectBy(name="p1"))
# !interactive
dbutils.getOrCreateProject("p2", interactive=False)
self._assertOneObject(Project.selectBy(name="p2"))
def testGetOrCreateProject(self):
# interactive
tui.addInputAnswers("y")
dbutils.getOrCreateProject("p1")
self._assertOneObject(Project.selectBy(name="p1"))
# !interactive
dbutils.getOrCreateProject("p2", interactive=False)
self._assertOneObject(Project.selectBy(name="p2"))
def testGetOrCreateProject(self):
# interactive
tui.addInputAnswers("y")
dbutils.getOrCreateProject("p1")
self.session.query(Project).filter_by(name="p1").one()
# !interactive
dbutils.getOrCreateProject("p2", interactive=False)
self.session.query(Project).filter_by(name="p2").one()
def testGetOrCreateKeyword(self):
# interactive
tui.addInputAnswers("y")
dbutils.getOrCreateKeyword("k1")
self.session.query(Keyword).filter_by(name="k1").one()
# !interactive
dbutils.getOrCreateKeyword("k2", interactive=False)
self.session.query(Keyword).filter_by(name="k2").one()
def testKRemove(self):
t1 = dbutils.addTask("x", "t1", dict(k1=12, k2=None), interactive=False)
tui.addInputAnswers("y")
self.cmd.do_k_remove("k1")
kwDict = t1.getKeywordDict()
self.assertFalse("k1" in kwDict)
self.assertTrue("k2" in kwDict)
taskKeyword = self.session.query(db.TaskKeyword).filter_by(taskId=t1.id).one()
self.assertEqual(taskKeyword.keyword.name, "k2")
def testSelectFromList(self):
lst = [("a", "alpha"), ("b", "bravo"), ("c", "charlie")]
tui.addInputAnswers("a")
value = tui.selectFromList(lst, valueForString=str)
self.assertEqual(value, "a")
tui.addInputAnswers("z", "b")
value = tui.selectFromList(lst, valueForString=str)
self.assertEqual(value, "b")
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 testGetOrCreateKeyword(self):
# interactive
tui.addInputAnswers("y")
dbutils.getOrCreateKeyword("k1")
self.session.query(Keyword).filter_by(name="k1").one()
# !interactive
dbutils.getOrCreateKeyword("k2", interactive=False)
self.session.query(Keyword).filter_by(name="k2").one()
def testGetOrCreateProject(self):
# interactive
tui.addInputAnswers("y")
dbutils.getOrCreateProject("p1")
self.session.query(Project).filter_by(name="p1").one()
# !interactive
dbutils.getOrCreateProject("p2", interactive=False)
self.session.query(Project).filter_by(name="p2").one()
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 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 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 testKEditNoMerge(self):
t1 = dbutils.addTask("x",
"t1",
dict(k1=12, k2=None),
interactive=False)
tui.addInputAnswers("newk1")
self.cmd.do_k_edit("k1")
kwDict = t1.getKeywordDict()
self.assertTrue("k1" not in kwDict)
self.assertEqual(kwDict.get("newk1"), 12)
self.assertRaises(YokadiException, dbutils.getKeywordFromName, "k1")
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 testIfEncrypted(self):
mgr = YokadiCryptoManager()
mgr.force_decrypt = True # Simulate user ask for decryption
tui.addInputAnswers("mySecretPassphrase")
important_sentence = "Don't tell anyone"
encrypted_sentence = mgr.encrypt(important_sentence)
self.assertTrue(mgr.isEncrypted(encrypted_sentence))
self.assertFalse(mgr.isEncrypted(important_sentence))
# Should not fail with empty data
self.assertFalse(mgr.isEncrypted(None))
def testEncrypt(self):
mgr = YokadiCryptoManager()
mgr.force_decrypt = True # Simulate user ask for decryption
tui.addInputAnswers("mySecretPassphrase")
important_sentence = "Don't tell anyone"
encrypted_sentence = mgr.encrypt(important_sentence)
decrypted_sentence = mgr.decrypt(encrypted_sentence)
self.assertEqual(important_sentence, decrypted_sentence)
# Enter again same passphrase and check it is ok
mgr = YokadiCryptoManager()
tui.addInputAnswers("mySecretPassphrase")
def testBadPassphrase(self):
mgr = YokadiCryptoManager()
mgr.force_decrypt = True # Simulate user ask for decryption
tui.addInputAnswers("mySecretPassphrase")
important_sentence = "Don't tell anyone"
encrypted_sentence = mgr.encrypt(important_sentence)
mgr = YokadiCryptoManager() # Define new manager with other passphrase
mgr.force_decrypt = True # Simulate user ask for decryption
tui.addInputAnswers("theWrongSecretPassphrase")
self.assertRaises(YokadiException, mgr.decrypt, encrypted_sentence)
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 testEncryptLongSentence(self):
mgr = YokadiCryptoManager()
mgr.force_decrypt = True # Simulate user ask for decryption
tui.addInputAnswers("mySecretPassphrase")
important_sentence = '''This sentence is long long long long
This sentence is long
This sentence is long
This sentence is long
This sentence is long long long'''
encrypted_sentence = mgr.encrypt(important_sentence)
decrypted_sentence = mgr.decrypt(encrypted_sentence)
self.assertEqual(important_sentence, decrypted_sentence)
def testGetTaskFromId(self):
tui.addInputAnswers("y")
t1 = dbutils.addTask("x", "t1", {})
task = dbutils.getTaskFromId(str(t1.id))
self.assertEqual(task, t1)
task = dbutils.getTaskFromId(t1.id)
self.assertEqual(task, t1)
task = dbutils.getTaskFromId(t1.uuid)
self.assertEqual(task, t1)
def testToTask(self):
tui.addInputAnswers("y")
self.cmd.do_n_add("x t1")
self.cmd.do_n_to_task(1)
task = self.session.query(Task).get(1)
self.assertFalse(task.isNote(self.session))
# Doing it twice should not fail
self.cmd.do_n_to_task(1)
task = self.session.query(Task).get(1)
self.assertFalse(task.isNote(self.session))
def testKEditCannotMerge(self):
"""
One can't merge keywords if they have different values
"""
t1 = dbutils.addTask("x", "t1", dict(k1=12, k2=None), interactive=False)
tui.addInputAnswers("k2", "y")
self.cmd.do_k_edit("k1")
kwDict = t1.getKeywordDict()
self.assertTrue("k1" in kwDict)
self.assertTrue("k2" in kwDict)
dbutils.getKeywordFromName("k1")
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 testKRemove(self):
t1 = dbutils.addTask("x",
"t1",
dict(k1=12, k2=None),
interactive=False)
tui.addInputAnswers("y")
self.cmd.do_k_remove("k1")
kwDict = t1.getKeywordDict()
self.assertFalse("k1" in kwDict)
self.assertTrue("k2" in kwDict)
taskKeyword = self.session.query(
db.TaskKeyword).filter_by(taskId=t1.id).one()
self.assertEqual(taskKeyword.keyword.name, "k2")
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))
