DeleteTodoItem.py

from src.entities.errors.NotFoundTodoItem import NotFoundTodoItem
from src.usecases.errors.invalidusererror import InvalidUserError
from src.entities.todolist import TodoList
from src.usecases.ports.todolistrepository import TodoListRepository


class DeleteTodoItem:
    def __init__(self, todolistrepository):
        self.todolistrepository: TodoListRepository = todolistrepository

    def perform(self, targettododescription, owneremail):
        ownertodolist: TodoList = self.todolistrepository.find_by_email(owneremail)
        if not ownertodolist:
            raise InvalidUserError()
        target_todo_index = ownertodolist.find_index(targettododescription)
        if target_todo_index < 0:
            raise NotFoundTodoItem()
        ownertodolist.remove(target_todo_index)
        self.todolistrepository.update(owneremail, ownertodolist)

deletetodoitem_test.py

import pytest

from src.usecases.createtodoitem import CreateTodoItem
from src.usecases.createtodolist import CreateTodoList
from src.usecases.deletetodoitem import DeleteTodoItem
from src.usecases.errors.invalidusererror import InvalidUserError
from src.usecases.signup import SignUp
from test.usecases.fakehashservice import FakeHashService
from test.usecases.inmemorytodolistrepository import InMemoryTodoListRepository
from test.usecases.inmemoryuserrepository import InMemoryUserRepository
from src.entities.errors.NotFoundTodoItem import NotFoundTodoItem


def test_try_delete_todo_of_user_that_dont_have_todo_list():
    user_repo = InMemoryUserRepository()
    hash_service = FakeHashService()
    in_memory_todolist_repository = InMemoryTodoListRepository()
    create_todo_list_use_case = CreateTodoList(user_repo, in_memory_todolist_repository)
    create_user_use_case = SignUp(user_repo, hash_service)
    delete_todo_item_use_case = DeleteTodoItem(in_memory_todolist_repository)
    user_name = "abc"
    user_email = "abc"
    user_pwd = "Abc@123"
    create_user_use_case.perform(user_name, user_email, user_pwd)
    create_todo_list_use_case.perform(user_email)
    with pytest.raises(InvalidUserError):
        delete_todo_item_use_case.perform("abc", "cde")

def test_try_delete_todo_of_user_that_dont_have_todo_item():
    user_repo = InMemoryUserRepository()
    hash_service = FakeHashService()
    in_memory_todolist_repository = InMemoryTodoListRepository()
    create_todo_list_use_case = CreateTodoList(user_repo, in_memory_todolist_repository)
    create_user_use_case = SignUp(user_repo, hash_service)
    delete_todo_item_use_case = DeleteTodoItem(in_memory_todolist_repository)
    create_todo_item_use_case = CreateTodoItem(in_memory_todolist_repository)
    user_name = "abc"
    user_email = "abc"
    user_email_2 = "random-email"
    user_pwd = "Abc@123"
    todo_description = "abc"
    todo_priority = 1
    create_user_use_case.perform(user_name, user_email, user_pwd)
    create_user_use_case.perform(user_name, user_email_2, user_pwd)
    create_todo_list_use_case.perform(user_email)
    create_todo_list_use_case.perform(user_email_2)
    create_todo_item_use_case.perform(user_email_2, todo_description, todo_priority)
    with pytest.raises(NotFoundTodoItem):
        delete_todo_item_use_case.perform(todo_description, user_email)

def test_try_delete_todo_of_user_that_have_todo_item():
    user_repo = InMemoryUserRepository()
    hash_service = FakeHashService()
    in_memory_todolist_repository = InMemoryTodoListRepository()
    create_todo_list_use_case = CreateTodoList(user_repo, in_memory_todolist_repository)
    create_user_use_case = SignUp(user_repo, hash_service)
    delete_todo_item_use_case = DeleteTodoItem(in_memory_todolist_repository)
    create_todo_item_use_case = CreateTodoItem(in_memory_todolist_repository)
    user_name = "abc"
    user_email = "abc"
    user_pwd = "Abc@123"
    todo_description = "abc"
    todo_priority = 1
    create_user_use_case.perform(user_name, user_email, user_pwd)
    create_todo_list_use_case.perform(user_email)
    create_todo_item_use_case.perform(user_email, todo_description, todo_priority)
    todo_list = in_memory_todolist_repository.find_by_email(user_email)
    todo_list_size_before = todo_list.size()
    delete_todo_item_use_case.perform(todo_description, user_email)
    assert todo_list_size_before > in_memory_todolist_repository.find_by_email(user_email).size()

NotFoundTodoItem.py

class NotFoundTodoItem(Exception):
    pass

todolist.py

from src.entities.errors.duplicateitemerror import DuplicateItemError


class TodoList:
    def __init__(self, owner):
        self.owner = owner
        self.list = []

    def add(self, item):
        self.check_duplicate(item.description)
        self.list.append(item)
        self.sort()

    def get(self, index):
        return self.list[index]

    def get_owner(self):
        return self.owner

    def complete(self, index):
        self.list[index].complete()
        self.sort()

    def complete_by_description(self, description):
        item = self.find(description)
        if item:
            item.complete()
            self.sort()

    def remove(self, index):
        self.list.pop(index)

    def size(self):
        return len(self.list)

    def find(self, description):
        for item in self.list:
            if item.description == description:
                return item

>>Adicionei isso    def find_index(self, description):
        index = -1
        for item in self.list:
            index = index + 1
            if item.description == description:
                break

        return index
<< Termina aqui
    def sort(self):
        self.list.sort()

    def change_priority_by_index(self, index, new_priority):
        self.list[index].change_priority(new_priority)
        self.list.sort()

    def change_priority_by_description(self, description, new_priority):
        item = self.find(description)
        if not item:
            return
        item.change_priority(new_priority)
        self.list.sort()

    def change_description(self, old_description, new_description):
        self.check_duplicate(new_description)
        item = self.find(old_description)
        if item:
            item.change_description(new_description)

    def check_duplicate(self, description):
        duplicate_item = self.find(description)
        if duplicate_item:
            raise DuplicateItemError()