def test_cli_project_create_already_exists(self):
project_identifier = "test_cli_project_create_already_exists"
project_create(project_identifier)
runner = CliRunner()
result = runner.invoke(cli_project_create, [project_identifier])
self.assertIsNone(result.exception)
self.assertIn("Failed to create project", result.output)
def test_task_search_by_end_date(self):
# GIVEN
expected_project_name = "test_task_search_by_all_criteria"
expected_end_date = "2020-01-31"
project_create(expected_project_name)
created_task = task_create(expected_project_name, 1)
task_update(expected_project_name, 1, end_date=expected_end_date)
# WHEN search is_closed=True (end_date not NULL)
found_tasks = task_search(project_name=expected_project_name,
task_number=1,
is_closed=True)
self.assertIsNotNone(found_tasks)
self.assertEqual(len(found_tasks), 1)
self.assertEqual(found_tasks[0], created_task)
# WHEN search is_closed=False (end_date is NULL)
found_tasks = task_search(project_name=expected_project_name,
task_number=1,
is_closed=False)
self.assertIsNotNone(found_tasks)
self.assertEqual(len(found_tasks), 0)
# WHEN search eq end_date
found_tasks = task_search(project_name=expected_project_name,
task_number=1,
end_date=expected_end_date,
date_operator="eq")
self.assertIsNotNone(found_tasks)
self.assertEqual(len(found_tasks), 1)
self.assertEqual(found_tasks[0], created_task)
# WHEN search lt end_date
found_tasks = task_search(project_name=expected_project_name,
task_number=1,
end_date="2020-02-01",
date_operator="lt")
self.assertIsNotNone(found_tasks)
self.assertEqual(len(found_tasks), 1)
self.assertEqual(found_tasks[0], created_task)
# WHEN search gt end_date
found_tasks = task_search(project_name=expected_project_name,
task_number=1,
end_date="2020-01-01",
date_operator="gt")
self.assertIsNotNone(found_tasks)
self.assertEqual(len(found_tasks), 1)
self.assertEqual(found_tasks[0], created_task)
# WHEN search le end_date
found_tasks = task_search(project_name=expected_project_name,
task_number=1,
end_date="2020-02-01",
date_operator="le")
self.assertIsNotNone(found_tasks)
self.assertEqual(len(found_tasks), 1)
self.assertEqual(found_tasks[0], created_task)
# WHEN search ge end_date
found_tasks = task_search(project_name=expected_project_name,
task_number=1,
end_date="2020-01-01",
date_operator="ge")
self.assertIsNotNone(found_tasks)
self.assertEqual(len(found_tasks), 1)
self.assertEqual(found_tasks[0], created_task)
def test_task_delete_not_existing_task(self):
# GIVEN
expected_project_name = "test_task_delete_not_existing_task"
project_create(expected_project_name)
# WHEN
deleted_task_count = task_delete(expected_project_name, 1)
# THEN
self.assertEqual(deleted_task_count, 0)
def test_task_create_find(self):
# GIVEN
project_create("PROJ4Task1")
# WHEN
task_create("PROJ4Task1", 1)
# THEN
found_task = task_find("PROJ4Task1", 1)
self.assertIsNotNone(found_task)
def test_task_search_not_existing_task(self):
# GIVEN
expected_project_name = "test_task_search_not_existing_task"
project_create(expected_project_name)
# WHEN
found_tasks = task_search(project_name=expected_project_name,
task_number=1)
self.assertIsNotNone(found_tasks)
self.assertEqual(len(found_tasks), 0)
def test_task_update_not_existing_task(self):
# GIVEN
project_create("test_task_update_not_existing_task")
# WHEN - THEN
with self.assertRaises(Exception) as context:
task_update("test_task_update_not_existing_task",
1,
description="not exists")
self.assertIn("not found task to update", str(context.exception))
def test_cli_project_find_by_name_exists(self):
project_identifier = "test_cli_project_find_by_name_exists"
project_create(project_identifier)
runner = CliRunner()
result = runner.invoke(cli_project_find, [project_identifier])
self.assertIsNone(result.exception)
self.assertIn(
"Found project with identifier {0}".format(project_identifier),
result.output)
def test_cli_task_create_with_project_name_exists(self):
project_identifier = "test_cli_task_create_with_project_name_exists"
project_create(project_identifier)
task_number = "1"
runner = CliRunner()
result = runner.invoke(cli_task_create,
[project_identifier, task_number])
self.assertIsNone(result.exception)
self.assertIn("Task created successfully", result.output)
def test_task_create_already_existing(self):
# GIVEN
expected_project_name = "test_task_create_already_existing"
project_create(expected_project_name)
task_create(expected_project_name, 1)
# WHEN - THEN
with self.assertRaises(Exception) as context:
task_create(expected_project_name, 1)
self.assertIn("already exists task number", str(context.exception))
def test_task_search_by_user(self):
# GIVEN
project_create("PROJ4TaskSearch")
task_create("PROJ4TaskSearch", 1)
user = user_create("PROJ4TaskSearch", "Mr. Lazy")
task_update("PROJ4TaskSearch", 1, user=user)
# WHEN
found_tasks = task_search(user_external_id=user.external_id)
self.assertIsNotNone(found_tasks)
self.assertEqual(len(found_tasks), 1)
def test_cli_project_delete_by_name(self):
project_identifier = "test_cli_project_delete_by_name"
project_create(project_identifier)
runner = CliRunner()
result = runner.invoke(cli_project_delete, [project_identifier])
self.assertIsNone(result.exception)
self.assertIn(
"Successfuly deleted project name: {0}".format(project_identifier),
result.output)
project_found = project_find(project_identifier)
self.assertIsNone(project_found)
def test_task_reset_end_date(self):
# GIVEN
expected_project_name = "test_task_reset_end_date"
project_create(expected_project_name)
task_create(expected_project_name, 1)
task_update(expected_project_name, 1, end_date="2020-01-01")
# WHEN
task_update(expected_project_name, 1, end_date="")
# THEN
found_task = task_find(expected_project_name, 1)
self.assertIsNotNone(found_task)
self.assertIsNone(found_task.end_date)
def test_cli_task_update_by_project_name_exists(self):
project_identifier = "test_cli_task_update_by_project_name_exists"
project_create(project_identifier)
task_number = "1"
task_create(project_identifier, task_number)
runner = CliRunner()
result = runner.invoke(cli_task_update,
[project_identifier, task_number])
self.assertIsNone(result.exception)
self.assertIn(
"Successfuly updated task number: {0} of project: {1}".format(
task_number, project_identifier), result.output)
def test_cli_project_search_not_closed(self):
project_identifier = "test_cli_project_search_not_closed"
project_create(project_identifier)
runner = CliRunner()
result = runner.invoke(cli_project_search, ["--is_closed", "true"])
self.assertIsNone(result.exception)
self.assertIn("Search properly finished", result.output)
self.assertNotIn(project_identifier, result.output)
result = runner.invoke(cli_project_search, ["--is_closed", "false"])
self.assertIsNone(result.exception)
self.assertIn("Search properly finished", result.output)
self.assertIn(project_identifier, result.output)
def test_cli_task_find_with_project_name_exists(self):
project_identifier = "test_cli_task_find_with_project_name_exists"
project_create(project_identifier)
task_number = "1"
task_create(project_identifier, task_number)
runner = CliRunner()
result = runner.invoke(cli_task_find,
[project_identifier, task_number])
self.assertIsNone(result.exception)
self.assertIn(
"Found task with project {0} and task number {1}".format(
project_identifier, task_number), result.output)
def test_task_reset_user(self):
# GIVEN
expected_project_name = "test_task_reset_user"
project_create(expected_project_name)
task_create(expected_project_name, 1)
user = user_create("USERtest_task_reset_user", "Mr. Lazy")
task_update(expected_project_name, 1, user=user)
# WHEN
task_update(expected_project_name, 1, user="")
# THEN
found_task = task_find(expected_project_name, 1)
self.assertIsNotNone(found_task)
self.assertIsNone(found_task.user)
def test_task_update_all_fields_by_project_name(self):
# GIVEN
project_create("PROJ4Task2")
task_create("PROJ4Task2", 2)
user = user_create("USER4TASK2", "Mr. Lazy")
# WHEN
task_update("PROJ4Task2", 2, "description task 2", "2020-01-01", user)
# THEN
found_task = task_find("PROJ4Task2", 2)
self.assertIsNotNone(found_task)
self.assertEqual(found_task.description, "description task 2")
self.assertEqual(found_task.end_date,
datetime.datetime(2020, 1, 1, 0, 0))
self.assertEqual(found_task.user, user)
def test_cli_project_update_by_name_exists(self):
project_identifier = "test_cli_project_update_by_name_exists"
expected_new_name = "test_cli_project_update_by_name_exists updated"
project_create(project_identifier)
runner = CliRunner()
result = runner.invoke(
cli_project_update,
[project_identifier, "--project_name", expected_new_name])
self.assertIsNone(result.exception)
self.assertIn(
"Successfuly updated project name: {0}".format(project_identifier),
result.output)
project_found = project_find(project_identifier)
self.assertIsNone(project_found)
project_found = project_find(expected_new_name)
self.assertIsNotNone(project_found)
def test_task_delete(self):
# GIVEN
project_create("PROJ4TaskDelete")
task_create("PROJ4TaskDelete", 1)
found_tasks = task_search(project_name="PROJ4TaskDelete",
task_number=1)
self.assertIsNotNone(found_tasks)
self.assertEqual(len(found_tasks), 1)
# WHEN
deleted_task_count = task_delete("PROJ4TaskDelete", 1)
# THEN
self.assertEqual(deleted_task_count, 1)
found_tasks = task_search(project_name="PROJ4TaskDelete",
task_number=1)
self.assertIsNotNone(found_tasks)
self.assertEqual(len(found_tasks), 0)
def test_cli_task_update_reset_user(self):
user = user_create("A10", "Kathir")
project_identifier = "test_cli_task_update_reset_user"
project_create(project_identifier)
task_number = "1"
task_create(project_identifier, task_number)
task = task_update(project_identifier, task_number, user=user)
self.assertIsNotNone(task.user)
runner = CliRunner()
result = runner.invoke(
cli_task_update,
[project_identifier, task_number, "--user_external_id", ""])
self.assertIsNone(result.exception)
self.assertIn(
"Successfuly updated task number: {0} of project: {1}".format(
task_number, project_identifier), result.output)
task_after_update = task_find(project_identifier, task_number)
self.assertIsNone(task_after_update.user)
def test_cli_project_find_by_id_exists(self):
project = project_create("test_cli_project_find_by_id_exists")
project_identifier = str(project.id)
runner = CliRunner()
result = runner.invoke(cli_project_find,
[project_identifier, "--identifier_type", "id"])
self.assertIsNone(result.exception)
self.assertIn(
"Found project with identifier {0}".format(project_identifier),
result.output)
def test_cli_task_create_with_project_id_exists(self):
project = project_create("test_cli_task_create_with_project_id_exists")
project_identifier = str(project.id)
task_number = "1"
runner = CliRunner()
result = runner.invoke(
cli_task_create,
["--identifier_type", "id", "--", project_identifier, task_number])
self.assertIsNone(result.exception)
self.assertIn("Task created successfully", result.output)
def test_cli_project_delete_by_id(self):
project = project_create("test_cli_project_delete_by_id")
project_identifier = str(project.id)
runner = CliRunner()
result = runner.invoke(cli_project_delete,
[project_identifier, "--identifier_type", "id"])
self.assertIsNone(result.exception)
self.assertIn(
"Successfuly deleted project name: {0}".format(project_identifier),
result.output)
project_found = project_find(project.id)
self.assertIsNone(project_found)
def test_cli_task_update_by_project_id_exists(self):
project = project_create("test_cli_task_update_by_project_id_exists")
project_identifier = str(project.id)
task_number = "1"
task_create(project.project_name, task_number)
runner = CliRunner()
result = runner.invoke(
cli_task_update,
["--identifier_type", "id", "--", project_identifier, task_number])
self.assertIsNone(result.exception)
self.assertIn(
"Successfuly updated task number: {0} of project: {1}".format(
task_number, project_identifier), result.output)
def test_cli_task_find_with_project_id_exists(self):
project = project_create("test_cli_task_find_with_project_id_exists")
project_identifier = str(project.id)
task_number = "1"
task_create(project.id, task_number)
runner = CliRunner()
result = runner.invoke(
cli_task_find,
["--identifier_type", "id", "--", project_identifier, task_number])
self.assertIsNone(result.exception)
self.assertIn(
"Found task with project {0} and task number {1}".format(
project_identifier, task_number), result.output)
def test_task_search_by_all_criteria(self):
# GIVEN
expected_project_name = "test_task_search_by_all_criteria"
expected_task_description = "desc test_task_search_by_all_criteria"
expected_end_date = "2020-01-31"
project_create(expected_project_name)
created_task = task_create(expected_project_name, 1)
user = user_create(expected_project_name, "Mr. Lazy")
task_update(expected_project_name,
1,
user=user,
description=expected_task_description,
end_date=expected_end_date)
# WHEN
found_tasks = task_search(user_external_id=user.external_id,
project_name=expected_project_name,
is_closed=True,
task_number=1,
end_date=expected_end_date,
date_operator="eq")
self.assertIsNotNone(found_tasks)
self.assertEqual(len(found_tasks), 1)
self.assertEqual(found_tasks[0], created_task)
def test_cli_project_update_by_id_exists(self):
expected_new_name = "test_cli_project_update_by_id_exists updated"
project = project_create("test_cli_project_update_by_id_exists")
project_identifier = str(project.id)
runner = CliRunner()
result = runner.invoke(cli_project_update, [
project_identifier, "--identifier_type", "id", "--project_name",
expected_new_name
])
self.assertIsNone(result.exception)
self.assertIn(
"Successfuly updated project name: {0}".format(project_identifier),
result.output)
project_found = project_find(project.id)
self.assertIsNotNone(project_found)
self.assertEqual(project_found.project_name, expected_new_name)
def test_task_find_not_existing_task_of_existing_project(self):
# GIVEN
project_create("RPOJ4test_task_find_not_existing")
# THEN
found_task = task_find("RPOJ4test_task_find_not_existing", 1)
self.assertIsNone(found_task)
