diff --git a/encryptdef/__main__.py b/encryptdef/__main__.py
index 8e1fbcf..6411034 100644
--- a/encryptdef/__main__.py
+++ b/encryptdef/__main__.py
@@ -1,7 +1,8 @@
 """Modulo que é o ponto de entrada do programa"""
 
-from encryptdef.cli import main
+from encryptdef.cli import main  # pragma: no cover
+
+if __name__ == "__main__":  # pragma: no cover
 
-if __name__ == "__main__":
     # Passando um contexto vazio
     main(ctx=None)
diff --git a/encryptdef/cli.py b/encryptdef/cli.py
index 57b18ce..794a117 100644
--- a/encryptdef/cli.py
+++ b/encryptdef/cli.py
@@ -41,7 +41,7 @@ def main(ctx: Optional[click.Context] = None) -> None:
     correta, não será possível desencriptar os dados ou arquivos.**
     """
     if ctx is None:
-        ctx = click.Context(main)
+        ctx = click.Context(main)  # pragma: no cover
 
     if ctx.invoked_subcommand is None:
         core.interactive_mode()
diff --git a/encryptdef/core.py b/encryptdef/core.py
index 42d6129..d621069 100644
--- a/encryptdef/core.py
+++ b/encryptdef/core.py
@@ -29,6 +29,7 @@
     TEMPLATE_DECRYPTED,
     TEMPLATE_DECRYPTED_FILE,
     TEMPLATE_DECRYPTED_MESSAGE,
+    TEMPLATE_EMPTY_FILE_ERROR,
     TEMPLATE_ENCRYPT_FILE,
     TEMPLATE_ENCRYPT_KEY,
     TEMPLATE_ENCRYPT_MESSAGE,
@@ -56,6 +57,10 @@ class InvalidKey(Exception):
     """Formato de string criptografada inválido"""
 
 
+class EmptyFileError(Exception):
+    """Formato de string criptografada inválido"""
+
+
 def encrypt(message: str, password: str) -> str:
     """
     Criptografa uma mensagem usando AES GCM com uma chave derivada por Scrypt.
@@ -227,7 +232,7 @@ def process_lines(
 
 
 def process_file_content(
-    file: str,
+    file_path: str,
     key: str,
     new_file_path: str,
     process_line_func: Callable[[str, str], Union[str, bool]],
@@ -236,7 +241,7 @@ def process_file_content(
     Processa o conteúdo de um arquivo e salva o resultado em um novo arquivo.
 
     Args:
-        file (str): Caminho do arquivo original.
+        file_path (str): Caminho do arquivo original.
         key (str): Chave para criptografar ou descriptografar.
         new_file_path (str): Caminho do novo arquivo.
         process_line_func (Callable[[str, str], Union[str, bool]]): Função para
@@ -245,13 +250,13 @@ def process_file_content(
     Returns:
         bool: True se o processamento for bem-sucedido, False caso contrário.
     """
-    lines = read_file(file)
+    lines = read_file(file_path)
+    if not lines:
+        raise EmptyFileError(TEMPLATE_EMPTY_FILE_ERROR % file_path)
+
     max_workers = print_get_max_workers(lines)
     processed_lines = process_lines(lines, key, process_line_func, max_workers)
 
-    if not processed_lines:
-        return False
-
     write_file(new_file_path, processed_lines)
     print_and_record_log(
         (
@@ -281,24 +286,25 @@ def process_file(
     Returns:
         bool: True se o processamento for bem-sucedido, False caso contrário.
     """
-    file, key, new_file = data_list
-
     try:
-        new_file_path = get_new_file_path(file, new_file, CURRENT_DIR)
+        file_path, key, new_file = data_list
+        new_file_path = get_new_file_path(file_path, new_file, CURRENT_DIR)
         return process_file_content(
-            file, key, new_file_path, process_line_func
+            file_path, key, new_file_path, process_line_func
         )
 
     except FileNotFoundError:
-        print_and_record_log(TEMPLATE_FILE_NOT_FOUND % file, "error")
+        print_and_record_log(TEMPLATE_FILE_NOT_FOUND % file_path, "error")
         console.print(TEMPLATE_INFO_FILE)
         return False
 
     except (
         TypeError,
         IsADirectoryError,
+        ValueError,
         InvalidEncryptedFormat,
         InvalidKey,
+        EmptyFileError,
     ) as e:
         print_and_record_log(str(e), "error")
         return False
@@ -307,7 +313,7 @@ def process_file(
 def process_keyfile_and_args(
     keyfile: Optional[str],
     message: Optional[str],
-    file: Optional[str],
+    file_: Optional[str],
     template_key: str,
 ) -> str:
     """
@@ -321,7 +327,7 @@ def process_keyfile_and_args(
         a chave será solicitada.
         message (Optional[str]): Dados para criptografar ou descriptografar.
         Usado se 'file' não for fornecido.
-        file (Optional[str]): Caminho do arquivo a ser criptografado ou
+        file_ (Optional[str]): Caminho do arquivo a ser criptografado ou
         descriptografado. Usado se 'message' não for fornecido.
         template_key (str): Template para solicitar a chave ao usuário,
         se necessário.
@@ -335,12 +341,12 @@ def process_keyfile_and_args(
         SystemExit: Se o arquivo de chave não for encontrado, ou se a chave
         fornecida for inválida.
     """
-    if message and file:
+    if message and file_:
         raise click.UsageError(
             "Você deve fornecer apenas um dos argumentos: --message ou --file,"
-            "não ambos."
+            " não ambos."
         )
-    if not message and not file:
+    if not message and not file_:
         raise click.UsageError(
             "Você deve fornecer um dos argumentos: --message ou --file."
         )
@@ -355,13 +361,9 @@ def process_keyfile_and_args(
     else:
         while not key or key.isspace():
             key = console.input(template_key, password=True).strip()
-            if key.isspace():
+            if not key:
                 print_and_record_log(TEMPLATE_ERROR_EMPTY_FIELD, "error")
 
-    if key is None:
-        print_and_record_log(TEMPLATE_ERROR_EMPTY_FIELD, "error")
-        sys.exit(1)
-
     return key
 
 
diff --git a/encryptdef/interactive_interface.py b/encryptdef/interactive_interface.py
index a8ef32e..710aadd 100644
--- a/encryptdef/interactive_interface.py
+++ b/encryptdef/interactive_interface.py
@@ -65,7 +65,6 @@ def validate_and_get_input(prompts: List[str]) -> List[str]:
             inputs = [
                 get_user_input(prompt, "🔑" in prompt) for prompt in prompts
             ]
-
             if any(not input for input in inputs):
                 raise ValueError(TEMPLATE_ERROR_EMPTY_FIELD)
             return inputs
@@ -174,15 +173,17 @@ def print_get_max_workers(lines: List[str]) -> int:
                 max_workers = 1
 
             if len(lines) > 500:
-                use_more_cores = int(
-                    console.input(TEMPLATE_GET_MAX_WORKERS % max_workers)
-                )
+                user_input = console.input(
+                    TEMPLATE_GET_MAX_WORKERS % max_workers
+                ).strip()
                 console.print("\n", end="")
 
-                if not use_more_cores or use_more_cores > max_workers:
+                if not user_input.isdigit() or not (
+                    0 < int(user_input) <= max_workers
+                ):
                     raise ValueError(TEMPLATE_ERROR_INVALID_CHOICE)
 
-                return use_more_cores
+                return int(user_input)
 
             return 1
 
diff --git a/encryptdef/log.py b/encryptdef/log.py
index 9c665a9..3586483 100644
--- a/encryptdef/log.py
+++ b/encryptdef/log.py
@@ -19,7 +19,7 @@
 
 
 def configure_logger(
-    logfile: Optional[Union[str, os.PathLike[str]]] = None
+    log_level: str, logfile: Optional[Union[str, os.PathLike[str]]] = None
 ) -> None:
     """Configura o logger com um handler de arquivo rotativo."""
     if logfile is None:
@@ -32,10 +32,10 @@ def configure_logger(
         fh = handlers.RotatingFileHandler(
             logfile, maxBytes=10**6, backupCount=10
         )
-        fh.setLevel(LOG_LEVEL)
+        fh.setLevel(log_level)
         fh.setFormatter(fmt)
         log_instance.addHandler(fh)
-        log_instance.setLevel(LOG_LEVEL)
+        log_instance.setLevel(log_level)
 
 
 def get_logger() -> logging.Logger:
@@ -44,7 +44,7 @@ def get_logger() -> logging.Logger:
 
 
 # Configure o logger ao importar o módulo
-configure_logger()
+configure_logger(LOG_LEVEL)
 
 log = get_logger()
 
diff --git a/encryptdef/template.py b/encryptdef/template.py
index c6de1c8..a8ac983 100644
--- a/encryptdef/template.py
+++ b/encryptdef/template.py
@@ -124,7 +124,10 @@
  ⚠  ERRO - FORMATO DE STRING CRIPTOGRAFADA INVÁLIDO!"""
 
 TEMPLATE_TYPE_ERROR = """
- ⚠  ERRO - ESPERADO UMA STRING, OBTIDO '%s'"""
+ ⚠  ERRO - ESPERADO UMA STRING, OBTIDO '%s'."""
 
 TEMPLATE_IS_DIRECTORY = """
  ⚠  ERRO - '%s' É UM DIRETÓRIO, NÃO UM ARQUIVO."""
+
+TEMPLATE_EMPTY_FILE_ERROR = """
+ ⚠  ERRO - ARQUIVO '%s' ESTÁ VAZIO."""
diff --git a/encryptdef/utils.py b/encryptdef/utils.py
index cc35245..6fa99c4 100644
--- a/encryptdef/utils.py
+++ b/encryptdef/utils.py
@@ -4,13 +4,8 @@
 import re
 from typing import List
 
-from colorama import init
-
 from encryptdef.template import TEMPLATE_IS_DIRECTORY
 
-# Inicializa colorama para garantir o funcionamento em sistemas Windows
-init()
-
 
 def get_new_file_path(file: str, new_file: str, current_dir: str) -> str:
     """
@@ -93,10 +88,9 @@ def write_file(new_file_path: str, processed_lines: List[str]) -> None:
 
 
 def clear_console():
-    """Limpa o console de forma segura."""
+    """Limpa o console de forma segura.
+    Utilizando sequências de escape ANSI"""
     if os.name == "posix":
         print("\033[H\033[J", end="")
     elif os.name == "nt":
-        # Inicializa o colorama, que é seguro e portátil
-        init()
         print("\033c", end="")
diff --git a/pyproject.toml b/pyproject.toml
index 4e649e7..88cfa42 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -40,6 +40,7 @@ local_scheme = "no-local-version" # determina a parte local (como dev1+g7aff1b9.
 minversion = "6.0"
 addopts = "-ra -q -vv"
 testpaths = "tests"
+filterwarnings = "ignore::DeprecationWarning:rich_click"
 
 [tool.flake8]
 exclude = [".venv", "build", ".vscodelocal", "migrations", "template.py"]
diff --git a/requirements.test.txt b/requirements.test.txt
index 8f0911e..bbe2d73 100644
--- a/requirements.test.txt
+++ b/requirements.test.txt
@@ -1,5 +1,6 @@
 #teste
 pytest
+pytest-mock
 
 # coverage
 coverage
diff --git a/requirements.txt b/requirements.txt
index eb72303..d957b74 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,3 +1,2 @@
 pycryptodomex >=3.20.0
 rich-click >=1.8.2
-colorama >=0.4.6
diff --git a/tests/conftest.py b/tests/conftest.py
index 929e30a..5a31e02 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -2,14 +2,6 @@
 
 import pytest
 
-MARKER = """\
-unit: Mark unit tests
-integration: Mark integration tests
-high: High Priority
-medium: Medium Priority
-low: Low Priority
-"""
-
 
 @pytest.fixture(autouse=True)
 def go_to_tmpdir(request):  # injeção de dependencias
diff --git a/tests/test_assigning_a_name_file.py b/tests/test_assigning_a_name_file.py
index 6a871ba..d10e4db 100644
--- a/tests/test_assigning_a_name_file.py
+++ b/tests/test_assigning_a_name_file.py
@@ -4,7 +4,7 @@
 
 
 def test_assigning_a_name_file_absolute():
-    """Test function assigning_a_name_file"""
+    """Testando a função assigning_a_name_file"""
     file = "/tmp/test/file-test-123.txt"
     name = "encrypt-"
     expected_result = "/tmp/test/encrypt-file-test-123.txt"
@@ -14,7 +14,7 @@ def test_assigning_a_name_file_absolute():
 
 
 def test_assigning_a_name_file_relative():
-    """Test function assigning_a_name_file"""
+    """Testando a função assigning_a_name_file"""
     file = "-123-file-test.txt"
     name = "decrypt-"
     expected_result = "decrypt--123-file-test.txt"
diff --git a/tests/test_decrypt.py b/tests/test_decrypt.py
new file mode 100644
index 0000000..feed0dc
--- /dev/null
+++ b/tests/test_decrypt.py
@@ -0,0 +1,74 @@
+"""Modulo para testar a função decrypt em core.py"""
+
+from base64 import b64decode, b64encode
+
+import pytest
+
+from encryptdef.core import (
+    InvalidEncryptedFormat,
+    InvalidKey,
+    decrypt,
+    encrypt,
+)
+from encryptdef.template import (
+    TEMPLATE_ERROR_INVALID_ENCRYPTED_FORMAT,
+    TEMPLATE_INVALID_KEY,
+)
+
+
+def test_decrypt_correct_message():
+    """Testa a função decrypt"""
+    message1 = "Message one: djas;kl/d<j@!#@'>$!@&()&&¨|#!@&*%#312312adasd"
+    password1 = "strongpassword123"
+
+    message2 = "Message two: 1~[]31'2>~[]dADd12<asS&(*¨*&¨#%@!#!@/HDJKA@!#"
+    password2 = "djas;kl/d<j@!#@'>$!@&()&&¨|#!@&*%#312312adasd"
+
+    encrypted_message1 = encrypt(message1, password1)
+    decrypted_message1 = decrypt(encrypted_message1, password1)
+
+    encrypted_message2 = encrypt(message2, password2)
+    decrypted_message2 = decrypt(encrypted_message2, password2)
+
+    assert decrypted_message1 == message1
+    assert decrypted_message2 == message2
+
+
+def test_decrypt_with_wrong_password():
+    """Testa a função decrypt"""
+    message = "This is a test message."
+    password = "strongpassword123"
+    wrong_password = "wrongpassword456"
+
+    encrypted_message = encrypt(message, password)
+
+    with pytest.raises(InvalidKey) as excinfo:
+        decrypt(encrypted_message, wrong_password)
+    assert str(excinfo.value) == TEMPLATE_INVALID_KEY
+
+
+def test_decrypt_invalid_format():
+    """Testa a função decrypt"""
+    invalid_encrypted_message = "invalid*encrypted*message-format"
+    password = "strongpassword123"
+
+    with pytest.raises(InvalidEncryptedFormat) as excinfo:
+        decrypt(invalid_encrypted_message, password)
+
+    assert str(excinfo.value) == TEMPLATE_ERROR_INVALID_ENCRYPTED_FORMAT
+
+
+def test_decrypt_with_modified_message():
+    """Testa a função decrypt"""
+    message = "This is a test message."
+    password = "strongpassword123"
+
+    encrypted_message = encrypt(message, password)
+    parts = encrypted_message.split("*")
+    modified_cipher_text = b64encode(b"modified" + b64decode(parts[0])).decode(
+        "utf-8"
+    )
+    modified_encrypted_message = "*".join([modified_cipher_text] + parts[1:])
+
+    with pytest.raises(InvalidKey):
+        decrypt(modified_encrypted_message, password)
diff --git a/tests/test_decrypt_message.py b/tests/test_decrypt_message.py
new file mode 100644
index 0000000..99c69fe
--- /dev/null
+++ b/tests/test_decrypt_message.py
@@ -0,0 +1,83 @@
+"""Modulo para testar a função decrypt_message em core.py"""
+
+from unittest.mock import patch
+
+from encryptdef.core import (
+    TEMPLATE_DECRYPTED,
+    TEMPLATE_DECRYPTED_MESSAGE,
+    InvalidEncryptedFormat,
+    InvalidKey,
+    decrypt_message,
+)
+
+ENCRYPT_MESSAGE = "cipher_text*salt*nonce*tag"
+CORRECT_KEY = "correct_key"
+WRONG_KEY = "wrong_key"
+
+
+# Mock das funções que produzem saídas
+@patch("encryptdef.core.print_success_message")
+@patch("encryptdef.core.print_and_record_log")
+def test_decrypt_message_success(
+    mock_print_and_record_log, mock_print_success_message
+):
+    """testar a função decrypt_message"""
+
+    # Mock da função decrypt para retornar a mensagem descriptografada esperada
+    with patch("encryptdef.core.decrypt", return_value="decrypted_message"):
+        result = decrypt_message(ENCRYPT_MESSAGE, CORRECT_KEY)
+
+    # Verifica se o resultado é True
+    assert result is True
+
+    # Verifica se a mensagem de sucesso foi chamada corretamente
+    mock_print_success_message.assert_called_once_with(
+        "decrypted_message",
+        TEMPLATE_DECRYPTED_MESSAGE,
+        TEMPLATE_DECRYPTED,
+    )
+
+    # Verifica se não houve chamadas de log de erro
+    mock_print_and_record_log.assert_not_called()
+
+
+@patch("encryptdef.core.print_success_message")
+@patch("encryptdef.core.print_and_record_log")
+def test_decrypt_message_invalid_key(
+    mock_print_and_record_log, mock_print_success_message
+):
+    """testar a função decrypt_message"""
+
+    # Mock da função decrypt para levantar um InvalidKey
+    with patch("encryptdef.core.decrypt", side_effect=InvalidKey):
+        result = decrypt_message(ENCRYPT_MESSAGE, WRONG_KEY)
+
+    # Verifica se o resultado é False
+    assert result is False
+
+    # Verifica se o log de erro foi chamado
+    mock_print_and_record_log.assert_called_once()
+
+    # Verifica se a mensagem de sucesso não foi chamada
+    mock_print_success_message.assert_not_called()
+
+
+@patch("encryptdef.core.print_success_message")
+@patch("encryptdef.core.print_and_record_log")
+def test_decrypt_message_invalid_format(
+    mock_print_and_record_log, mock_print_success_message
+):
+    """testar a função decrypt_message"""
+
+    # Mock da função decrypt para levantar um InvalidEncryptedFormat
+    with patch("encryptdef.core.decrypt", side_effect=InvalidEncryptedFormat):
+        result = decrypt_message("invalid_format", CORRECT_KEY)
+
+    # Verifica se o resultado é False
+    assert result is False
+
+    # Verifica se o log de erro foi chamado
+    mock_print_and_record_log.assert_called_once()
+
+    # Verifica se a mensagem de sucesso não foi chamada
+    mock_print_success_message.assert_not_called()
diff --git a/tests/test_encrypt.py b/tests/test_encrypt.py
new file mode 100644
index 0000000..d43c616
--- /dev/null
+++ b/tests/test_encrypt.py
@@ -0,0 +1,55 @@
+"""Modulo para testar a função encrypt em core.py"""
+
+import base64
+
+import pytest
+
+from encryptdef.core import encrypt
+
+
+def test_encrypt_output_format():
+    """Testa a função encrypt"""
+    message = "This is a test message."
+    password = "strongpassword123"
+
+    encrypted_message = encrypt(message, password)
+
+    # Verificar se a mensagem criptografada contém 4 partes separadas por '*'
+    parts = encrypted_message.split("*")
+    assert (
+        len(parts) == 4
+    ), "Encrypted message should contain 4 parts separated by '*'"
+
+    # Verificar se cada parte pode ser decodificada de base64
+    cipher_text, salt, nonce, tag = parts
+    try:
+        base64.b64decode(cipher_text)
+        base64.b64decode(salt)
+        base64.b64decode(nonce)
+        base64.b64decode(tag)
+    except TypeError:
+        pytest.fail("One of the parts could not be base64 decoded")
+
+
+def test_encrypt_different_messages():
+    """Testa a função encrypt diferentes valores e mesma senha"""
+    password = "strongpassword123"
+    message1 = "Message one"
+    message2 = "Message two"
+
+    encrypted_message1 = encrypt(message1, password)
+    encrypted_message2 = encrypt(message2, password)
+
+    assert encrypted_message1 != encrypted_message2
+
+
+def test_encrypt_same_message_different_passwords():
+    """Testa a função encrypt diferentes senhas e mesmo valor"""
+    message = "This is a test message."
+    password1 = "password123"
+    password2 = "differentpassword456"
+
+    encrypted_message1 = encrypt(message, password1)
+    encrypted_message2 = encrypt(message, password2)
+
+    assert encrypted_message1 != encrypted_message2
diff --git a/tests/test_encrypt_message.py b/tests/test_encrypt_message.py
new file mode 100644
index 0000000..c4b6aad
--- /dev/null
+++ b/tests/test_encrypt_message.py
@@ -0,0 +1,32 @@
+"""Modulo para testar a função encrypt_message em core.py"""
+
+from unittest.mock import patch
+
+from encryptdef.core import encrypt_message
+from encryptdef.template import TEMPLATE_ENCRYPTED, TEMPLATE_ENCRYPTED_MESSAGE
+
+ENCRYPT_MESSAGE = "cipher_text*salt*nonce*tag"
+CORRECT_KEY = "correct_key"
+
+
+# Mock das funções que produzem saídas
+@patch("encryptdef.core.print_success_message")
+@patch("encryptdef.core.print_and_record_log")
+def test_encrypt_message_success(
+    mock_print_and_record_log, mock_print_success_message
+):
+    """testar a função encrypt_message"""
+
+    # Mock da função decrypt para retornar a mensagem descriptografada esperada
+    with patch("encryptdef.core.encrypt", return_value="encrypt_message"):
+        encrypt_message(ENCRYPT_MESSAGE, CORRECT_KEY)
+
+    # Verifica se a mensagem de sucesso foi chamada corretamente
+    mock_print_success_message.assert_called_once_with(
+        "encrypt_message",
+        TEMPLATE_ENCRYPTED_MESSAGE,
+        TEMPLATE_ENCRYPTED,
+    )
+
+    # Verifica se não houve chamadas de log de erro
+    mock_print_and_record_log.assert_not_called()
diff --git a/tests/test_get_new_file_path.py b/tests/test_get_new_file_path.py
index f95a50a..dfb4552 100644
--- a/tests/test_get_new_file_path.py
+++ b/tests/test_get_new_file_path.py
@@ -8,7 +8,7 @@
 
 
 def test_get_new_file_path_positive():
-    """Test function get_new_file_path"""
+    """Testando a função get_new_file_path"""
     current_dir = os.getcwd()
     file = "file_test.txt"
     new_file = "encrypt_file_test.txt"
@@ -19,7 +19,7 @@ def test_get_new_file_path_positive():
 
 
 def test_get_new_file_path_is_directory_error():
-    """Test function get_new_file_path"""
+    """Testando a função get_new_file_path"""
     current_dir = os.getcwd()
     directoty = "new_directory"
     directoty_path = os.path.join(current_dir, directoty)
@@ -33,7 +33,7 @@ def test_get_new_file_path_is_directory_error():
 
 
 def test_get_new_file_path_positive_exact_file_path():
-    """Test function get_new_file_path"""
+    """Testando a função get_new_file_path"""
     file = "file_test.txt"
     new_file = "encrypt_file_test.txt"
 
diff --git a/tests/test_integration/test_cli/test_decrypt.py b/tests/test_integration/test_cli/test_decrypt.py
new file mode 100644
index 0000000..d14eb9f
--- /dev/null
+++ b/tests/test_integration/test_cli/test_decrypt.py
@@ -0,0 +1,84 @@
+"""Modulo para testar a função decrypt em cli.py"""
+
+from unittest.mock import patch
+
+import pytest
+from click.testing import CliRunner
+
+from encryptdef import core
+from encryptdef.cli import main
+from encryptdef.template import TEMPLATE_DECRYPT_KEY
+
+
+@pytest.fixture(name="runner")
+def runner_fixture():
+    """Função fixture para teste"""
+    return CliRunner()
+
+
+@patch("encryptdef.cli.core.decrypt_message")
+@patch("encryptdef.cli.core.process_keyfile_and_args", return_value="mock_key")
+def test_encrypt_command_with_message(
+    mock_process_keyfile, mock_decrypt_message, runner
+):
+    """Teste para o comando decrypt com uma mensagem."""
+
+    result = runner.invoke(
+        main, ["decrypt", "--message", "encrypt-helloworld"]
+    )
+    assert result.exit_code == 0
+    mock_process_keyfile.assert_called_once_with(
+        None, "encrypt-helloworld", None, TEMPLATE_DECRYPT_KEY
+    )
+    mock_decrypt_message.assert_called_once_with(
+        "encrypt-helloworld", "mock_key"
+    )
+
+
+@patch("encryptdef.cli.core.process_file")
+@patch("encryptdef.cli.assigning_a_name_file", return_value="decrypt-test.txt")
+@patch("encryptdef.cli.core.process_keyfile_and_args", return_value="mock_key")
+def test_encrypt_command_with_file(
+    mock_process_keyfile,
+    mock_assigning,
+    mock_process_file,
+    runner,
+):
+    """Teste para o comando decrypt com um arquivo."""
+
+    result = runner.invoke(main, ["decrypt", "--file", "encrypt-test.txt"])
+    assert result.exit_code == 0
+    mock_process_keyfile.assert_called_once_with(
+        None, None, "encrypt-test.txt", TEMPLATE_DECRYPT_KEY
+    )
+    mock_assigning.assert_called_once_with("encrypt-test.txt", "decrypt-")
+    mock_process_file.assert_called_once_with(
+        ["encrypt-test.txt", "mock_key", "decrypt-test.txt"], core.decrypt
+    )
+
+
+@patch("encryptdef.cli.core.process_file")
+@patch("encryptdef.cli.assigning_a_name_file", return_value="decrypt-test.txt")
+@patch(
+    "encryptdef.cli.core.process_keyfile_and_args",
+    return_value="mock_key_file",
+)
+def test_encrypt_command_with_file_with_keyfile(
+    mock_process_keyfile,
+    mock_assigning,
+    mock_process_file,
+    runner,
+):
+    """Teste para o comando decrypt com um arquivo e keyfile"""
+
+    result = runner.invoke(
+        main, ["decrypt", "--keyfile", "key.txt", "--file", "encrypt-test.txt"]
+    )
+    assert result.exit_code == 0
+    mock_process_keyfile.assert_called_once_with(
+        "key.txt", None, "encrypt-test.txt", TEMPLATE_DECRYPT_KEY
+    )
+    mock_assigning.assert_called_once_with("encrypt-test.txt", "decrypt-")
+    mock_process_file.assert_called_once_with(
+        ["encrypt-test.txt", "mock_key_file", "decrypt-test.txt"], core.decrypt
+    )
diff --git a/tests/test_integration/test_cli/test_encrypt.py b/tests/test_integration/test_cli/test_encrypt.py
new file mode 100644
index 0000000..50006ca
--- /dev/null
+++ b/tests/test_integration/test_cli/test_encrypt.py
@@ -0,0 +1,80 @@
+"""Modulo para testar a função encrypt em cli.py"""
+
+from unittest.mock import patch
+
+import pytest
+from click.testing import CliRunner
+
+from encryptdef import core
+from encryptdef.cli import main
+from encryptdef.template import TEMPLATE_ENCRYPT_KEY
+
+
+@pytest.fixture(name="runner")
+def runner_fixture():
+    """Função fixture para teste"""
+    return CliRunner()
+
+
+@patch("encryptdef.cli.core.encrypt_message")
+@patch("encryptdef.cli.core.process_keyfile_and_args", return_value="mock_key")
+def test_encrypt_command_with_message(
+    mock_process_keyfile, mock_encrypt_message, runner
+):
+    """Teste para o comando encrypt com uma mensagem."""
+
+    result = runner.invoke(main, ["encrypt", "--message", "hello world"])
+    assert result.exit_code == 0
+    mock_process_keyfile.assert_called_once_with(
+        None, "hello world", None, TEMPLATE_ENCRYPT_KEY
+    )
+    mock_encrypt_message.assert_called_once_with("hello world", "mock_key")
+
+
+@patch("encryptdef.cli.core.process_file")
+@patch("encryptdef.cli.assigning_a_name_file", return_value="encrypt-test.txt")
+@patch("encryptdef.cli.core.process_keyfile_and_args", return_value="mock_key")
+def test_encrypt_command_with_file(
+    mock_process_keyfile,
+    mock_assigning,
+    mock_process_file,
+    runner,
+):
+    """Teste para o comando encrypt com um arquivo."""
+
+    result = runner.invoke(main, ["encrypt", "--file", "test.txt"])
+    assert result.exit_code == 0
+    mock_process_keyfile.assert_called_once_with(
+        None, None, "test.txt", TEMPLATE_ENCRYPT_KEY
+    )
+    mock_assigning.assert_called_once_with("test.txt", "encrypt-")
+    mock_process_file.assert_called_once_with(
+        ["test.txt", "mock_key", "encrypt-test.txt"], core.encrypt
+    )
+
+
+@patch("encryptdef.cli.core.process_file")
+@patch("encryptdef.cli.assigning_a_name_file", return_value="encrypt-test.txt")
+@patch(
+    "encryptdef.cli.core.process_keyfile_and_args",
+    return_value="mock_key_file",
+)
+def test_encrypt_command_with_file_with_keyfile(
+    mock_process_keyfile,
+    mock_assigning,
+    mock_process_file,
+    runner,
+):
+    """Teste para o comando encrypt com um arquivo e keyfile"""
+
+    result = runner.invoke(
+        main, ["encrypt", "--keyfile", "key.txt", "--file", "test.txt"]
+    )
+    assert result.exit_code == 0
+    mock_process_keyfile.assert_called_once_with(
+        "key.txt", None, "test.txt", TEMPLATE_ENCRYPT_KEY
+    )
+    mock_assigning.assert_called_once_with("test.txt", "encrypt-")
+    mock_process_file.assert_called_once_with(
+        ["test.txt", "mock_key_file", "encrypt-test.txt"], core.encrypt
+    )
diff --git a/tests/test_integration/test_cli/test_main.py b/tests/test_integration/test_cli/test_main.py
new file mode 100644
index 0000000..d46c410
--- /dev/null
+++ b/tests/test_integration/test_cli/test_main.py
@@ -0,0 +1,32 @@
+"""Modulo para testar a função main em cli.py"""
+
+from unittest.mock import patch
+
+import pytest
+from click.testing import CliRunner
+
+from encryptdef.cli import main
+
+
+@pytest.fixture(name="runner")
+def runner_fixture():
+    """Função fixture para teste"""
+    return CliRunner()
+
+
+@patch("encryptdef.core.interactive_mode")
+def test_main_no_command(mock_interactive, runner):
+    """Teste para a função main sem nenhum subcomando."""
+    result = runner.invoke(main)
+    assert result.exit_code == 0
+    mock_interactive.assert_called_once()
+
+
+def test_main_command_help(runner):
+    """Teste para o comando encrypt --help"""
+    result = runner.invoke(main, ["encrypt", "--help"])
+    assert result.exit_code == 0
+    assert "OPTIONS" in result.output
+    assert "encrypt" in result.output
+    assert "--message" in result.output
+    assert "--file" in result.output
diff --git a/tests/test_integration/test_cli/test_process_keyfile_and_args_input.py b/tests/test_integration/test_cli/test_process_keyfile_and_args_input.py
new file mode 100644
index 0000000..91ee3f8
--- /dev/null
+++ b/tests/test_integration/test_cli/test_process_keyfile_and_args_input.py
@@ -0,0 +1,46 @@
+""" Modulo para testar a função process_keyfile_and_args em core.py"""
+
+from unittest.mock import patch
+
+from encryptdef.core import process_keyfile_and_args
+from encryptdef.template import TEMPLATE_ERROR_EMPTY_FIELD
+
+
+def test_process_keyfile_and_args_input_key_success(monkeypatch):
+    """Testa a função process_keyfile_and_args"""
+    # Define a chave de entrada que será retornada pelo mock
+    test_key = "test_key"
+
+    # Usa monkeypatch para substituir console.input para sempre retornar
+    # 'test_key'
+    # A função lambda aceita quaisquer argumentos posicionais (*args)
+    # e quaisquer argumentos nomeados (**kwargs) que possam ser passados para
+    # console.input
+    monkeypatch.setattr(
+        "encryptdef.core.console.input", lambda *args, **kwargs: test_key
+    )
+
+    # Chama a função com os argumentos apropriados e verifica se a chave
+    # retornada é 'test_key'
+    key = process_keyfile_and_args(None, "message", None, "template_key")
+    assert key == test_key
+
+
+def test_process_keyfile_and_args_key_isspace():
+    """Testa a função process_keyfile_and_args"""
+    with (
+        patch("encryptdef.core.read_file", return_value=[]),
+        patch(
+            "encryptdef.core.console.input", side_effect=["   ", "valid_key"]
+        ),
+        patch("encryptdef.core.print_and_record_log") as mock_log,
+    ):
+
+        process_keyfile_and_args(
+            keyfile=None,
+            message="fake_message",
+            file_=None,
+            template_key="Enter key",
+        )
+
+        mock_log.assert_called_with(TEMPLATE_ERROR_EMPTY_FIELD, "error")
diff --git a/tests/test_integration/test_interactive/test_get_user_input.py b/tests/test_integration/test_interactive/test_get_user_input.py
new file mode 100644
index 0000000..ef7a945
--- /dev/null
+++ b/tests/test_integration/test_interactive/test_get_user_input.py
@@ -0,0 +1,17 @@
+"""Modulo para testar a função get_user_input em interactive_interface.py"""
+
+from unittest.mock import patch
+
+from encryptdef.interactive_interface import get_user_input
+
+
+def test_get_user_input_sucess():
+    """Testa a função print_template_logo"""
+    with (
+        patch("encryptdef.interactive_interface.console.input") as mock_input,
+    ):
+        prompt_test = "test"
+        password_test = True
+        get_user_input(prompt_test, password_test)
+
+        mock_input.assert_called_with("test", password=True)
diff --git a/tests/test_integration/test_interactive/test_print_continue_or_leave.py b/tests/test_integration/test_interactive/test_print_continue_or_leave.py
new file mode 100644
index 0000000..985ae49
--- /dev/null
+++ b/tests/test_integration/test_interactive/test_print_continue_or_leave.py
@@ -0,0 +1,17 @@
+"""Modulo para testar a função print_continue_or_leave
+em interactive_interface.py"""
+
+from unittest.mock import patch
+
+from encryptdef.interactive_interface import print_continue_or_leave
+
+
+def test_print_continue_or_leave_sucess():
+    """Testa a função print_continue_or_leave"""
+    with (
+        patch("encryptdef.interactive_interface.get_user_input") as mock_input,
+    ):
+        template_test = "template test"
+        print_continue_or_leave(template_test)
+
+        mock_input.assert_called_with("template test")
diff --git a/tests/test_integration/test_interactive/test_print_get_mas_workers.py b/tests/test_integration/test_interactive/test_print_get_mas_workers.py
new file mode 100644
index 0000000..ee418bc
--- /dev/null
+++ b/tests/test_integration/test_interactive/test_print_get_mas_workers.py
@@ -0,0 +1,52 @@
+"""Modulo para testar a função print_get_max_workers
+em interactive_interface.py"""
+
+from unittest.mock import patch
+
+from encryptdef.interactive_interface import print_get_max_workers
+from encryptdef.template import TEMPLATE_ERROR_INVALID_CHOICE
+
+
+def test_print_get_max_workers_few_lines():
+    """Função de teste quando o número de linhas é menor ou igual a 500"""
+    lines = ["line"] * 500
+    result = print_get_max_workers(lines)
+    assert result == 1
+
+
+@patch("os.cpu_count", return_value=4)
+@patch("encryptdef.interactive_interface.console.input", return_value="2")
+def test_print_get_max_workers_many_lines_valid_choice(
+    mock_cpu_count, mock_input
+):  # pylint: disable=W0613
+    """Função de testa número de linhas maior que 500"""
+    lines = ["line"] * 501
+    result = print_get_max_workers(lines)
+    assert result == 2
+
+
+@patch("os.cpu_count", return_value=4)
+@patch(
+    "encryptdef.interactive_interface.console.input",
+    side_effect=["10", "*", " ", "dasd", "d", "E", "-1", "2"],
+)
+@patch("encryptdef.interactive_interface.print_and_record_log")
+def test_print_get_max_workers_many_lines_invalid_choice(
+    mock_log, mock_input, mock_cpu_count
+):  # pylint: disable=W0613
+    """Função de testa se o valor do input é valido"""
+    lines = ["line"] * 501
+    result = print_get_max_workers(lines)
+    assert result == 2
+    mock_log.assert_called_with(TEMPLATE_ERROR_INVALID_CHOICE, "error")
+
+
+@patch("os.cpu_count", return_value=None)
+@patch("encryptdef.interactive_interface.console.input", return_value="1")
+def test_print_get_max_workers_cpu_count_none(
+    mock_cpu_count, mock_input
+):  # pylint: disable=W0613
+    """Função de teste quando os.cpu_count retorna None"""
+    lines = ["line"] * 501
+    result = print_get_max_workers(lines)
+    assert result == 1
diff --git a/tests/test_integration/test_interactive/test_print_request_menu.py b/tests/test_integration/test_interactive/test_print_request_menu.py
new file mode 100644
index 0000000..3d8fea2
--- /dev/null
+++ b/tests/test_integration/test_interactive/test_print_request_menu.py
@@ -0,0 +1,111 @@
+"""Modulo para testar a função print_request_menu
+em interactive_interface.py"""
+
+from unittest.mock import patch
+
+import pytest
+
+from encryptdef.interactive_interface import print_request_menu
+from encryptdef.template import (
+    TEMPLATE_ERROR_INVALID_CHOICE,
+    TEMPLATE_MENU_ENCRYPT_DECRYPT,
+    TEMPLATE_MENU_MESSAGE_FILE,
+)
+
+
+@pytest.fixture(name="mock_print_template_logo")
+def mock_print_template_logo_fixture():
+    """Função fixture para teste"""
+    with patch(
+        "encryptdef.interactive_interface.print_template_logo"
+    ) as mock_logo:
+        yield mock_logo
+
+
+@pytest.fixture(name="mock_console_input")
+def mock_console_input_fixture():
+    """Função fixture para teste"""
+    with patch("encryptdef.interactive_interface.console.input") as mock_input:
+        yield mock_input
+
+
+@pytest.fixture(name="mock_console_print")
+def mock_console_print_fixture():
+    """Função fixture para teste"""
+    with patch("encryptdef.interactive_interface.console.print") as mock_print:
+        yield mock_print
+
+
+@pytest.fixture(name="mock_clear_console")
+def mock_clear_console_fixture():
+    """Função fixture para teste"""
+    with patch("encryptdef.interactive_interface.clear_console") as mock_clear:
+        yield mock_clear
+
+
+@pytest.fixture(name="mock_print_and_record_log")
+def mock_print_and_record_log_fixture():
+    """Função fixture para teste"""
+    with patch(
+        "encryptdef.interactive_interface.print_and_record_log"
+    ) as mock_log:
+        yield mock_log
+
+
+def test_print_request_menu_valid_choice(
+    mock_print_template_logo,
+    mock_console_input,
+    mock_console_print,
+):
+    """Testa a função print_request_menu"""
+
+    mock_console_input.return_value = "1"
+
+    # Chamando a função e verificando se a escolha retornada é correta
+    choice = print_request_menu(TEMPLATE_MENU_MESSAGE_FILE)
+    assert choice == 1
+
+    # Verificando se as funções foram chamadas
+    mock_print_template_logo.assert_called_with(info=True)
+    mock_console_print.assert_any_call(TEMPLATE_MENU_MESSAGE_FILE)
+
+
+def test_print_request_menu_exit_choice(
+    mock_print_template_logo,
+    mock_console_input,
+    mock_console_print,
+):
+    """Testa a função print_request_menu"""
+
+    mock_console_input.return_value = "3"
+
+    with pytest.raises(SystemExit):
+        print_request_menu(TEMPLATE_MENU_MESSAGE_FILE)
+
+        # Verificando se a função foi chamada
+        mock_print_template_logo.assert_called_with(info=True)
+        mock_console_print.assert_any_call(TEMPLATE_MENU_MESSAGE_FILE)
+
+
+def test_print_request_menu_invalid_choice(
+    mock_clear_console,
+    mock_print_and_record_log,
+    mock_print_template_logo,
+    mock_console_input,
+    mock_console_print,
+):
+    """Testa a função print_request_menu"""
+    mock_console_input.side_effect = ["0", "4", "-1", "10", "2"]
+
+    # Chamando a função e verificando se a escolha retornada é correta
+    choice = print_request_menu(TEMPLATE_MENU_ENCRYPT_DECRYPT)
+    assert choice == 2
+
+    # Verificando se as funções foram chamadas
+    assert mock_clear_console.call_count == 4
+    assert mock_print_template_logo.call_count == 5
+    mock_print_template_logo.assert_called_with(info=True)
+    mock_print_and_record_log.assert_called_with(
+        TEMPLATE_ERROR_INVALID_CHOICE, "error"
+    )
+    mock_console_print.assert_any_call(TEMPLATE_MENU_ENCRYPT_DECRYPT)
diff --git a/tests/test_integration/test_interactive/test_print_requesting_file.py b/tests/test_integration/test_interactive/test_print_requesting_file.py
new file mode 100644
index 0000000..88a2b55
--- /dev/null
+++ b/tests/test_integration/test_interactive/test_print_requesting_file.py
@@ -0,0 +1,41 @@
+"""Modulo para testar a função print_requesting_file
+em interactive_interface.py"""
+
+from unittest.mock import patch
+
+from encryptdef.interactive_interface import print_requesting_file
+from encryptdef.template import TEMPLATE_DECRYPT_FILE, TEMPLATE_ENCRYPT_FILE
+
+
+def test_print_requesting_file_encrypt_sucess():
+    """Testa a função print_requesting_file"""
+    with (
+        patch(
+            "encryptdef.interactive_interface.get_user_input",
+            return_value="data_test",
+        ),
+        patch(
+            "encryptdef.interactive_interface.print_template_logo"
+        ) as mock_template,
+    ):
+
+        tuple_data = print_requesting_file(TEMPLATE_ENCRYPT_FILE)
+        mock_template.assert_called_once()
+        assert tuple_data == ["data_test", "data_test", "data_test"]
+
+
+def test_print_requesting_file_decrypt_sucess():
+    """Testa a função print_requesting_file"""
+    with (
+        patch(
+            "encryptdef.interactive_interface.get_user_input",
+            return_value="data_test",
+        ),
+        patch(
+            "encryptdef.interactive_interface.print_template_logo"
+        ) as mock_template,
+    ):
+
+        tuple_data = print_requesting_file(TEMPLATE_DECRYPT_FILE)
+        mock_template.assert_called_once()
+        assert tuple_data == ["data_test", "data_test", "data_test"]
diff --git a/tests/test_integration/test_interactive/test_print_requesting_message.py b/tests/test_integration/test_interactive/test_print_requesting_message.py
new file mode 100644
index 0000000..711f203
--- /dev/null
+++ b/tests/test_integration/test_interactive/test_print_requesting_message.py
@@ -0,0 +1,25 @@
+"""Modulo para testar a função print_requesting_message
+em interactive_interface.py"""
+
+from unittest.mock import patch
+
+from encryptdef.interactive_interface import print_requesting_message
+
+
+def test_print_requesting_message_sucess():
+    """Testa a função validate_and_get_input"""
+    with (
+        patch(
+            "encryptdef.interactive_interface.get_user_input",
+            return_value="data_test",
+        ),
+        patch(
+            "encryptdef.interactive_interface.print_template_logo"
+        ) as mock_template,
+    ):
+
+        tuple_data = print_requesting_message(
+            "template_message_test", "template_key_test"
+        )
+        assert tuple_data == ("data_test", "data_test")
+        mock_template.assert_called_once()
diff --git a/tests/test_integration/test_interactive/test_print_sucess_message.py b/tests/test_integration/test_interactive/test_print_sucess_message.py
new file mode 100644
index 0000000..e55f14e
--- /dev/null
+++ b/tests/test_integration/test_interactive/test_print_sucess_message.py
@@ -0,0 +1,48 @@
+"""Modulo para testar a função print_success_message
+em interactive_interface.py"""
+
+from unittest.mock import patch
+
+from encryptdef.interactive_interface import print_success_message
+from encryptdef.template import (
+    TEMPLATE_DECRYPTED,
+    TEMPLATE_DECRYPTED_MESSAGE,
+    TEMPLATE_ENCRYPTED,
+    TEMPLATE_ENCRYPTED_MESSAGE,
+)
+
+
+def test_print_sucess_message_template_encrypt():
+    """Testa a função validate_and_get_input"""
+    with (
+        patch(
+            "encryptdef.interactive_interface.print_and_record_log"
+        ) as mock_log,
+    ):
+        message = "encrypt message test"
+        print_success_message(
+            message, TEMPLATE_ENCRYPTED_MESSAGE, TEMPLATE_ENCRYPTED
+        )
+
+        mock_log.assert_any_call(TEMPLATE_ENCRYPTED_MESSAGE, "debug")
+        mock_log.assert_any_call(TEMPLATE_ENCRYPTED % message, "debug")
+
+        mock_log.call_count = 2
+
+
+def test_print_sucess_message_template_decrypt():
+    """Testa a função validate_and_get_input"""
+    with (
+        patch(
+            "encryptdef.interactive_interface.print_and_record_log"
+        ) as mock_log,
+    ):
+        message = "encrypt message test"
+        print_success_message(
+            message, TEMPLATE_DECRYPTED_MESSAGE, TEMPLATE_DECRYPTED
+        )
+
+        mock_log.assert_any_call(TEMPLATE_DECRYPTED_MESSAGE, "debug")
+        mock_log.assert_any_call(TEMPLATE_DECRYPTED % message, "debug")
+
+        mock_log.call_count = 2
diff --git a/tests/test_integration/test_interactive/test_print_template_logo.py b/tests/test_integration/test_interactive/test_print_template_logo.py
new file mode 100644
index 0000000..1c0f50e
--- /dev/null
+++ b/tests/test_integration/test_interactive/test_print_template_logo.py
@@ -0,0 +1,67 @@
+"""Modulo para testar a função print_template_logo
+em interactive_interface.py"""
+
+from unittest.mock import patch
+
+import pytest
+
+from encryptdef.interactive_interface import print_template_logo
+from encryptdef.template import TEMPLATE_INFO, TEMPLATE_LOGO
+
+
+@pytest.fixture(name="mock_console_print")
+def mock_console_print_fixture():
+    """Função fixture para teste"""
+    with patch("encryptdef.interactive_interface.console.print") as mock_input:
+        yield mock_input
+
+
+@pytest.fixture(name="mock_clear_console")
+def mock_clear_console_fixture():
+    """Função fixture para teste"""
+    with patch("encryptdef.interactive_interface.clear_console") as mock_clear:
+        yield mock_clear
+
+
+@pytest.fixture(name="mock_markdown")
+def mock_markdown_fixture():
+    """Função fixture para teste"""
+    with patch("encryptdef.interactive_interface.Markdown") as mock_mark:
+        yield mock_mark
+
+
+def test_print_template_logo_default(mock_clear_console, mock_console_print):
+    """Testa a função print_template_logo"""
+
+    # Teste quando info é False
+    print_template_logo(info=False)
+
+    # Assegura que clear_console foi chamado
+    mock_clear_console.assert_called_once()
+
+    # Assegura que TEMPLATE_LOGO foi impresso
+    mock_console_print.assert_called_once_with(TEMPLATE_LOGO)
+
+
+def test_print_template_logo_with_info(
+    mock_markdown, mock_clear_console, mock_console_print
+):
+    """Testa a função print_template_logo"""
+
+    # Mock do objeto Markdown
+    mock_md = mock_markdown.return_value
+
+    # Teste quando info é True
+    print_template_logo(info=True)
+
+    # Assegura que clear_console foi chamado
+    mock_clear_console.assert_called_once()
+
+    # Assegura que TEMPLATE_LOGO foi impresso
+    mock_console_print.assert_any_call(TEMPLATE_LOGO)
+
+    # Assegura que TEMPLATE_INFO foi transformado em Markdown
+    mock_markdown.assert_called_once_with(TEMPLATE_INFO)
+
+    # Assegura que o Markdown foi impresso
+    mock_console_print.assert_any_call(mock_md)
diff --git a/tests/test_integration/test_interactive/test_validate_and_get_input.py b/tests/test_integration/test_interactive/test_validate_and_get_input.py
new file mode 100644
index 0000000..f727678
--- /dev/null
+++ b/tests/test_integration/test_interactive/test_validate_and_get_input.py
@@ -0,0 +1,57 @@
+"""Modulo para testar a função validate_and_get_input
+em interactive_interface.py"""
+
+from unittest.mock import patch
+
+from encryptdef.interactive_interface import validate_and_get_input
+from encryptdef.template import (
+    TEMPLATE_ENCRYPT_FILE,
+    TEMPLATE_ENCRYPT_KEY,
+    TEMPLATE_ENCRYPT_MESSAGE,
+    TEMPLATE_ERROR_EMPTY_FIELD,
+)
+
+
+def test_validate_and_get_input_valid():
+    """Testa a função validate_and_get_input"""
+
+    # Mockando a função get_user_input para retornar entradas válidas
+    with patch(
+        "encryptdef.interactive_interface.get_user_input",
+        side_effect=["message", "password123"],
+    ):
+        prompts = [TEMPLATE_ENCRYPT_MESSAGE, TEMPLATE_ENCRYPT_KEY]
+        # Chama a função verificando se as entradas são retornadas corretamente
+        inputs = validate_and_get_input(prompts)
+        assert inputs == ["message", "password123"]
+
+
+def test_validate_and_get_input_empty_field():
+    """Testa a função validate_and_get_input"""
+
+    with (
+        patch(
+            "encryptdef.interactive_interface.get_user_input",
+            side_effect=[
+                "",
+                "password123",
+                "new_file",
+                "file",
+                "password123",
+                "new_file",
+            ],
+        ),
+        patch(
+            "encryptdef.interactive_interface.print_and_record_log"
+        ) as mock_log,
+        patch("encryptdef.interactive_interface.clear_console") as mock_clear,
+        patch(
+            "encryptdef.interactive_interface.print_template_logo"
+        ) as mock_template,
+    ):
+
+        inputs = validate_and_get_input(TEMPLATE_ENCRYPT_FILE.split("\n"))
+        assert inputs == ["file", "password123", "new_file"]
+        mock_clear.assert_called()
+        mock_template.assert_called()
+        mock_log.assert_called_with(TEMPLATE_ERROR_EMPTY_FIELD, "error")
diff --git a/tests/test_interactive_mode.py b/tests/test_interactive_mode.py
new file mode 100644
index 0000000..0b1d7e4
--- /dev/null
+++ b/tests/test_interactive_mode.py
@@ -0,0 +1,164 @@
+"""Modulo para testar a função interactive_mode em core.py"""
+
+from unittest.mock import patch
+
+import pytest
+
+from encryptdef.core import decrypt, encrypt, interactive_mode
+from encryptdef.template import (
+    TEMPLATE_DECRYPT_FILE,
+    TEMPLATE_DECRYPT_KEY,
+    TEMPLATE_DECRYPT_MESSAGE,
+    TEMPLATE_ENCRYPT_FILE,
+    TEMPLATE_ENCRYPT_KEY,
+    TEMPLATE_ENCRYPT_MESSAGE,
+)
+
+
+@pytest.fixture(name="mock_console_input")
+def mock_console_input_fixture():
+    """Função fixture para teste"""
+    with patch("encryptdef.core.console.input") as mock_input:
+        yield mock_input
+
+
+@pytest.fixture(name="mock_print_request_menu")
+def mock_print_request_menu_fixture():
+    """Função fixture para teste"""
+    with patch("encryptdef.core.print_request_menu") as mock_menu:
+        yield mock_menu
+
+
+@pytest.fixture(name="mock_print_requesting_message")
+def mock_print_requesting_message_fixture():
+    """Função fixture para teste"""
+    with patch("encryptdef.core.print_requesting_message") as mock_message:
+        yield mock_message
+
+
+@pytest.fixture(name="mock_print_requesting_file")
+def mock_print_requesting_file_fixture():
+    """Função fixture para teste"""
+    with patch("encryptdef.core.print_requesting_file") as mock_file:
+        yield mock_file
+
+
+@pytest.fixture(name="mock_encrypt_message")
+def mock_encrypt_message_fixture():
+    """Função fixture para teste"""
+    with patch("encryptdef.core.encrypt_message") as mock_encrypt:
+        yield mock_encrypt
+
+
+@pytest.fixture(name="mock_decrypt_message")
+def mock_decrypt_message_fixture():
+    """Função fixture para teste"""
+    with patch("encryptdef.core.decrypt_message") as mock_decrypt:
+        yield mock_decrypt
+
+
+@pytest.fixture(name="mock_process_file")
+def mock_process_file_fixture():
+    """Função fixture para teste"""
+    with patch("encryptdef.core.process_file") as mock_process:
+        yield mock_process
+
+
+@pytest.fixture(name="mock_print_continue_or_leave")
+def mock_print_continue_or_leave_fixture():
+    """Função fixture para teste"""
+    with patch("encryptdef.core.print_continue_or_leave") as mock_continue:
+        yield mock_continue
+
+
+def test_encrypt_message(
+    mock_print_request_menu,
+    mock_print_requesting_message,
+    mock_encrypt_message,
+    mock_print_continue_or_leave,
+):
+    """Testa a função interactive_mode"""
+
+    # Escolha criptografar mensagem
+    mock_print_request_menu.side_effect = [1, 1]
+    mock_print_requesting_message.return_value = (
+        "Mensagem de Teste",
+        "SenhaDeTeste",
+    )
+    # Termina após uma iteração
+    mock_print_continue_or_leave.return_value = True
+
+    interactive_mode()
+
+    mock_print_request_menu.assert_called()
+    mock_print_requesting_message.assert_called_once_with(
+        TEMPLATE_ENCRYPT_MESSAGE, TEMPLATE_ENCRYPT_KEY
+    )
+    mock_encrypt_message.assert_called_once_with(
+        "Mensagem de Teste", "SenhaDeTeste"
+    )
+
+
+def test_decrypt_message(
+    mock_print_request_menu,
+    mock_print_requesting_message,
+    mock_decrypt_message,
+    mock_print_continue_or_leave,
+):
+    """Testa a função interactive_mode"""
+
+    mock_print_request_menu.side_effect = [1, 2]
+    mock_print_requesting_message.return_value = (
+        "Mensagem Criptografada",
+        "SenhaDeTeste",
+    )
+    mock_print_continue_or_leave.return_value = True
+
+    interactive_mode()
+
+    mock_print_request_menu.assert_called()
+    mock_print_requesting_message.assert_called_once_with(
+        TEMPLATE_DECRYPT_MESSAGE, TEMPLATE_DECRYPT_KEY
+    )
+    mock_decrypt_message.assert_called_once_with(
+        "Mensagem Criptografada", "SenhaDeTeste"
+    )
+
+
+def test_encrypt_file(
+    mock_print_request_menu,
+    mock_print_requesting_file,
+    mock_process_file,
+    mock_print_continue_or_leave,
+):
+    """Testa a função interactive_mode"""
+    mock_print_request_menu.side_effect = [2, 1]
+    mock_print_requesting_file.return_value = ["file_path", "key", "new_file"]
+    mock_print_continue_or_leave.return_value = True
+
+    interactive_mode()
+
+    mock_print_request_menu.assert_called()
+    mock_print_requesting_file.assert_called_once_with(TEMPLATE_ENCRYPT_FILE)
+    mock_process_file.assert_called_once_with(
+        ["file_path", "key", "new_file"], encrypt
+    )
+
+
+def test_decrypt_file(
+    mock_print_request_menu,
+    mock_print_requesting_file,
+    mock_process_file,
+    mock_print_continue_or_leave,
+):
+    mock_print_request_menu.side_effect = [2, 2]
+    mock_print_requesting_file.return_value = ["file_path", "key", "new_file"]
+    mock_print_continue_or_leave.return_value = True
+
+    interactive_mode()
+
+    mock_print_request_menu.assert_called()
+    mock_print_requesting_file.assert_called_once_with(TEMPLATE_DECRYPT_FILE)
+    mock_process_file.assert_called_once_with(
+        ["file_path", "key", "new_file"], decrypt
+    )
diff --git a/tests/test_log.py b/tests/test_log.py
new file mode 100644
index 0000000..660350f
--- /dev/null
+++ b/tests/test_log.py
@@ -0,0 +1,106 @@
+""" Modulo para testar  log.py"""
+
+import logging
+import os
+from logging import handlers
+from unittest.mock import patch
+
+from encryptdef.log import configure_logger, get_logger, print_and_record_log
+
+
+def clear_logger_handlers():
+    """Função para limpar as configurações do log"""
+    logger = get_logger()
+    logger.handlers.clear()  # Limpa todos os handlers
+    logger.setLevel(logging.NOTSET)  # Redefine o nível do logger
+    # Garante que o logger não propague para loggers de nível superior
+    logger.propagate = False
+    logging.basicConfig(
+        level=logging.NOTSET
+    )  # Redefine a configuração básica do logging
+
+
+def create_log_file():
+    """Criando um arquivo de log no diretorio atual"""
+    clear_logger_handlers()
+    current_dir = os.getcwd()
+    logfile = os.path.join(current_dir, "encryptdef.log")
+    configure_logger("WARNING", logfile)
+
+    return logfile
+
+
+def test_configure_logger_creates_logfile():
+    """Testando as configurações de log"""
+    logfile = create_log_file()
+    logger = get_logger()
+
+    assert any(
+        isinstance(handler, handlers.RotatingFileHandler)
+        for handler in logger.handlers
+    )
+    assert logger.level == logging.WARNING
+    assert os.path.isfile(logfile)
+
+
+def test_get_logger():
+    """Testando a função get_looger"""
+    clear_logger_handlers()
+    logger = get_logger()
+    assert logger is not None
+    assert isinstance(logger, logging.Logger)
+    assert logger.name == "encryptdef"
+
+
+def test_print_and_record_log_info():
+    """Testando o conteudo do arquivo log em modo info"""
+    clear_logger_handlers()
+    current_dir = os.getcwd()
+    logfile = os.path.join(current_dir, "encryptdef.log")
+    configure_logger("INFO", logfile)
+    get_logger()
+
+    with patch("encryptdef.settings.console.print") as mock_console_print:
+        print_and_record_log("Info message")
+        mock_console_print.assert_called_once_with(
+            "Info message", style="info"
+        )
+
+    with open(logfile, "r", encoding="utf-8") as log_file:
+        log_contents = log_file.read()
+        assert "Info message" in log_contents
+
+
+def test_print_and_record_log_warning():
+    """Testando o conteudo do arquivo log em modo warning"""
+    clear_logger_handlers()
+    logfile = create_log_file()
+    get_logger()
+
+    with patch("encryptdef.settings.console.print") as mock_console_print:
+        print_and_record_log("Info message", "warning")
+        mock_console_print.assert_called_once_with(
+            "Info message", style="warning"
+        )
+
+    with open(logfile, "r", encoding="utf-8") as log_file:
+        log_contents = log_file.read()
+        assert "Info message" in log_contents
+
+
+def test_configure_logger_creates_logfile_root_dir(monkeypatch):
+    """Testando as configurações de log"""
+    clear_logger_handlers()
+    current_dir = os.getcwd()
+    logfile = os.path.join(current_dir, "encryptdef.log")
+    monkeypatch.setattr("encryptdef.log.__file__", logfile)
+
+    configure_logger("WARNING")
+    logger = get_logger()
+
+    assert any(
+        isinstance(handler, handlers.RotatingFileHandler)
+        for handler in logger.handlers
+    )
+    assert logger.level == logging.WARNING
+    assert os.path.isfile(logfile)
diff --git a/tests/test_process_file.py b/tests/test_process_file.py
new file mode 100644
index 0000000..c2af0e3
--- /dev/null
+++ b/tests/test_process_file.py
@@ -0,0 +1,124 @@
+""" Modulo para testar a função process_file em core.py"""
+
+import os
+from unittest.mock import patch
+
+from encryptdef.core import InvalidEncryptedFormat, InvalidKey, process_file
+from encryptdef.template import (
+    TEMPLATE_EMPTY_FILE_ERROR,
+    TEMPLATE_FILE_NOT_FOUND,
+    TEMPLATE_IS_DIRECTORY,
+    TEMPLATE_TYPE_ERROR,
+)
+
+
+# Funções de criptografia e descriptografia simuladas para testes
+def mock_encrypt(message, key):  # pylint: disable=W0613
+    """Função exemplo de encrypt"""
+    return f"encrypted-{message}"
+
+
+def mock_decrypt(message, key):  # pylint: disable=W0613
+    """Função exemplo de decrypt"""
+    if "invalid" in message:
+        raise InvalidKey("Invalid key")
+    return f"decrypted-{message}"
+
+
+def mock_process_line_func_invalid(line, key):  # pylint: disable=W0613
+    """Função exemplo de retorno invalido"""
+    return 123
+
+
+def test_process_file_success():
+    """Testa a função process_file"""
+
+    # Substitui as funções reais por mocks durante o teste
+    with (
+        patch("encryptdef.core.read_file") as mock_read_file,
+        patch("encryptdef.core.write_file") as mock_write_file,
+    ):
+        data_list = ["/path/to/file", "key", "new_file"]
+
+        mock_read_file.return_value = ["line1", "line2"]
+
+        assert process_file(data_list, mock_encrypt) is True
+        mock_read_file.assert_called_once_with("/path/to/file")
+        mock_write_file.assert_called_once_with(
+            "new_file", ["encrypted-line1\n", "encrypted-line2\n"]
+        )
+
+
+def test_process_file_file_not_found():
+    """Testa a função process_file"""
+    with (
+        patch("encryptdef.core.console") as mock_console,
+        patch("encryptdef.core.print_and_record_log") as mock_log,
+        patch("encryptdef.core.read_file", side_effect=FileNotFoundError),
+    ):
+        data_list = ["/path/to/file", "key", "new_file"]
+        assert process_file(data_list, mock_encrypt) is False
+        mock_log.assert_called_with(
+            TEMPLATE_FILE_NOT_FOUND % "/path/to/file", "error"
+        )
+        mock_console.print.assert_called()
+
+
+def test_process_file_invalid_encrypted_format():
+    """Testa a função process_file"""
+    with (
+        patch("encryptdef.core.print_and_record_log") as mock_log,
+        patch(
+            "encryptdef.core.process_file_content",
+            side_effect=InvalidEncryptedFormat("Invalid format"),
+        ),
+    ):
+        data_list = ["/path/to/file", "key", "new_file"]
+        assert process_file(data_list, mock_encrypt) is False
+        mock_log.assert_called_with("Invalid format", "error")
+
+
+def test_process_file_invalid_key():
+    """Testa a função process_file"""
+    with (
+        patch("encryptdef.core.print_and_record_log") as mock_log,
+        patch("encryptdef.core.read_file", return_value=["invalid"]),
+    ):
+        data_list = ["/path/to/file", "invalid-key", "new_file"]
+        assert process_file(data_list, mock_decrypt) is False
+        mock_log.assert_called_with("Invalid key", "error")
+
+
+def test_process_file_empty_file():
+    """Testa a função process_file"""
+    with (
+        patch("encryptdef.core.print_and_record_log") as mock_log,
+        patch("encryptdef.core.read_file", return_value=[]),
+    ):
+        data_list = ["/path/to/file", "key", "new_file"]
+        assert process_file(data_list, mock_decrypt) is False
+        mock_log.assert_called_with(
+            TEMPLATE_EMPTY_FILE_ERROR % "/path/to/file", "error"
+        )
+
+
+def test_process_file_is_adirectory_error():
+    """Testa a função process_file"""
+    with patch("encryptdef.core.print_and_record_log") as mock_log:
+        current_dir = os.getcwd()
+        data_list = [current_dir, "key", "new_file"]
+        assert process_file(data_list, mock_decrypt) is False
+        mock_log.assert_called_with(
+            TEMPLATE_IS_DIRECTORY % current_dir, "error"
+        )
+
+
+def test_process_file_type_error():
+    """Testa a função process_file"""
+    with (
+        patch("encryptdef.core.print_and_record_log") as mock_log,
+        patch("encryptdef.core.read_file", return_value=["invalid"]),
+    ):
+        data_list = ["/path/to/file", "key", "new_file"]
+        assert process_file(data_list, mock_process_line_func_invalid) is False
+        mock_log.assert_called_with(TEMPLATE_TYPE_ERROR % {type(123)}, "error")
diff --git a/tests/test_process_file_content.py b/tests/test_process_file_content.py
new file mode 100644
index 0000000..34e3cd2
--- /dev/null
+++ b/tests/test_process_file_content.py
@@ -0,0 +1,178 @@
+"""Modulo para testar a função process_file_content em core.py"""
+
+from unittest.mock import patch
+
+import pytest
+
+from encryptdef.core import (
+    EmptyFileError,
+    decrypt,
+    encrypt,
+    process_file_content,
+)
+from encryptdef.template import (
+    TEMPLATE_DECRYPTED_FILE,
+    TEMPLATE_ENCRYPTED_FILE,
+)
+
+
+def process_lines_func(x, y):  # pylint: disable=W0613
+    """Simula função de processamento de linha"""
+    return x
+
+
+def test_process_file_content_success():
+    """Testa a função process_file_content"""
+
+    # Substitui as funções reais por mocks durante o teste
+    with (
+        patch("encryptdef.core.read_file") as mock_read_file,
+        patch("encryptdef.core.print_get_max_workers") as mock_get_max_workers,
+        patch("encryptdef.core.process_lines") as mock_process_lines,
+        patch("encryptdef.core.write_file") as mock_write_file,
+        patch("encryptdef.core.print_and_record_log") as mock_log,
+    ):
+
+        # Simula a leitura de um arquivo
+        mock_read_file.return_value = ["line1\n", "line2\n"]
+
+        # Simula o cálculo de trabalhadores máximos
+        mock_get_max_workers.return_value = 2
+
+        # Simula o processamento das linhas, retornando linhas processadas
+        mock_process_lines.return_value = [
+            "encrypted_line1\n",
+            "encrypted_line2\n",
+        ]
+        result = process_file_content(
+            "testfile.txt", "key", "newfile.txt", process_lines_func
+        )
+
+        assert result is True
+
+        # Verifica se read_file foi chamado com o argumento 'testfile.txt'
+        mock_read_file.assert_called_once_with("testfile.txt")
+        mock_get_max_workers.assert_called_once()
+
+        # Verifica se process_lines foi chamado uma vez com os argumentos
+        mock_process_lines.assert_called_once_with(
+            ["line1\n", "line2\n"], "key", process_lines_func, 2
+        )
+        mock_write_file.assert_called_once_with(
+            "newfile.txt", ["encrypted_line1\n", "encrypted_line2\n"]
+        )
+
+        # Verifica se print_and_record_log foi chamado uma vez
+        mock_log.assert_called_once()
+
+
+def test_process_file_content_empty_file():
+    """Testa a função process_file_content"""
+    with patch("encryptdef.core.read_file") as mock_read_file:
+        mock_read_file.return_value = []
+
+        with pytest.raises(EmptyFileError):
+            process_file_content(
+                "testfile.txt", "key", "newfile.txt", lambda x, y: x
+            )
+
+
+def test_process_file_content_multithreading():
+    """Testa a função process_file_content"""
+    with (
+        patch("encryptdef.core.read_file") as mock_read_file,
+        patch("encryptdef.core.print_get_max_workers") as mock_get_max_workers,
+        patch("encryptdef.core.process_lines") as mock_process_lines,
+        patch("encryptdef.core.write_file") as mock_write_file,
+    ):
+
+        mock_read_file.return_value = [
+            "line1\n",
+            "line2\n",
+            "line3\n",
+            "line4\n",
+        ]
+        mock_get_max_workers.return_value = 4
+        mock_process_lines.return_value = [
+            "processed_line1\n",
+            "processed_line2\n",
+            "processed_line3\n",
+            "processed_line4\n",
+        ]
+
+        result = process_file_content(
+            "testfile.txt", "key", "newfile.txt", process_lines_func
+        )
+
+        assert result is True
+        mock_read_file.assert_called_once_with("testfile.txt")
+        mock_get_max_workers.assert_called_once()
+        mock_process_lines.assert_called_once_with(
+            ["line1\n", "line2\n", "line3\n", "line4\n"],
+            "key",
+            process_lines_func,
+            4,
+        )
+        mock_write_file.assert_called_once_with(
+            "newfile.txt",
+            [
+                "processed_line1\n",
+                "processed_line2\n",
+                "processed_line3\n",
+                "processed_line4\n",
+            ],
+        )
+
+
+def test_process_file_content_log_encrypt():
+    """Testa a função process_file_content"""
+    with (
+        patch("encryptdef.core.read_file") as mock_read_file,
+        patch("encryptdef.core.print_get_max_workers") as mock_get_max_workers,
+        patch("encryptdef.core.process_lines") as mock_process_lines,
+        patch("encryptdef.core.write_file"),
+        patch("encryptdef.core.print_and_record_log") as mock_log,
+    ):
+
+        mock_read_file.return_value = ["line1\n", "line2\n"]
+        mock_get_max_workers.return_value = 2
+        mock_process_lines.return_value = [
+            "encrypted_line1\n",
+            "encrypted_line2\n",
+        ]
+
+        process_line_func = encrypt
+        result = process_file_content(
+            "testfile.txt", "key", "newfile.txt", process_line_func
+        )
+
+        assert result is True
+        expected_log_message = TEMPLATE_ENCRYPTED_FILE % "newfile.txt"
+        mock_log.assert_called_with(expected_log_message, "debug")
+
+
+def test_process_file_content_log_decrypt():
+    """Testa a função process_file_content"""
+    with (
+        patch("encryptdef.core.read_file") as mock_read_file,
+        patch("encryptdef.core.print_get_max_workers") as mock_get_max_workers,
+        patch("encryptdef.core.process_lines") as mock_process_lines,
+        patch("encryptdef.core.write_file"),
+        patch("encryptdef.core.print_and_record_log") as mock_log,
+    ):
+
+        mock_read_file.return_value = ["line1\n", "line2\n"]
+        mock_get_max_workers.return_value = 2
+        mock_process_lines.return_value = [
+            "decrypted_line1\n",
+            "decrypted_line2\n",
+        ]
+
+        process_line_func = decrypt
+        result = process_file_content(
+            "testfile.txt", "key", "newfile.txt", process_line_func
+        )
+
+        assert result is True
+        expected_log_message = TEMPLATE_DECRYPTED_FILE % "newfile.txt"
+        mock_log.assert_called_with(expected_log_message, "debug")
diff --git a/tests/test_process_keyfile_and_args.py b/tests/test_process_keyfile_and_args.py
new file mode 100644
index 0000000..cac1f78
--- /dev/null
+++ b/tests/test_process_keyfile_and_args.py
@@ -0,0 +1,53 @@
+"""Modulo para testar a função process_file_content em core.py"""
+
+from unittest.mock import patch
+
+import pytest
+import rich_click as click
+
+from encryptdef.core import process_keyfile_and_args
+from encryptdef.template import TEMPLATE_FILE_NOT_FOUND
+
+
+def test_process_keyfile_and_args_both_message_and_file_error():
+    """Testa a função process_keyfile_and_args"""
+    click_error = (
+        "Você deve fornecer apenas um dos argumentos: --message ou --file,"
+        " não ambos."
+    )
+    with pytest.raises(click.UsageError) as error:
+        process_keyfile_and_args("keyfile", "message", "file", "template_key")
+
+    assert str(error.value) == click_error
+
+
+def test_process_keyfile_and_args_neither_message_nor_file_error():
+    """Testa a função process_keyfile_and_args"""
+    click_error = "Você deve fornecer um dos argumentos: --message ou --file."
+    with pytest.raises(click.UsageError) as error:
+        process_keyfile_and_args("keyfile", None, None, "template_key")
+
+    assert str(error.value) == click_error
+
+
+def test_process_keyfile_and_args_keyfile_not_found():
+    """Testa a função process_keyfile_and_args"""
+    with (
+        patch("encryptdef.core.print_and_record_log") as mock_log,
+        patch("encryptdef.core.read_file", side_effect=FileNotFoundError),
+    ):
+        with pytest.raises(SystemExit):
+            process_keyfile_and_args(
+                "non_existent_keyfile", None, "file", "template_key"
+            )
+
+        mock_log.assert_called_with(
+            TEMPLATE_FILE_NOT_FOUND % "non_existent_keyfile", "error"
+        )
+
+
+def test_process_keyfile_and_args_keyfile_success():
+    """Testa a função process_keyfile_and_args"""
+    with patch("encryptdef.core.read_file", return_value=["test_key"]):
+        key = process_keyfile_and_args("keyfile", None, "file", "template_key")
+        assert key == "test_key"
diff --git a/tests/test_process_lines.py b/tests/test_process_lines.py
new file mode 100644
index 0000000..a34ef75
--- /dev/null
+++ b/tests/test_process_lines.py
@@ -0,0 +1,139 @@
+"""Modulo para testar a função process_lines em core.py"""
+
+import pytest
+
+from encryptdef.core import decrypt, encrypt, process_lines
+
+
+# Funções de exemplo para processamento de linha
+def mock_process_line_func(line, key):
+    """Função exemplo process_line"""
+    return f"processed_{line}_with_{key}"
+
+
+def mock_process_line_func_invalid(line, key):  # pylint: disable=W0613
+    """Função exemplo de retorno invalido"""
+    return 123  # Deve ser string, mas retorna int para simular erro
+
+
+def mock_process_line_func_exception(line, key):
+    """Função exemplo de expection"""
+    raise ValueError("Simulated processing error")
+
+
+def test_process_lines_basic():
+    """Testa a função process_lines"""
+    lines = ["line1", "line2", "line3"]
+    key = "testkey"
+    max_workers = 2
+    processed_lines = process_lines(
+        lines, key, mock_process_line_func, max_workers
+    )
+    expected = [
+        "processed_line1_with_testkey\n",
+        "processed_line2_with_testkey\n",
+        "processed_line3_with_testkey\n",
+    ]
+    assert processed_lines == expected
+
+
+def test_process_lines_empty():
+    """Testa a função process_lines"""
+    lines = []
+    key = "testkey"
+    max_workers = 2
+    processed_lines = process_lines(
+        lines, key, mock_process_line_func, max_workers
+    )
+    assert processed_lines == []
+
+
+def test_process_lines_single_worker():
+    """Testa a função process_lines"""
+    lines = ["line1"]
+    key = "testkey"
+    max_workers = 1
+    processed_lines = process_lines(
+        lines, key, mock_process_line_func, max_workers
+    )
+    expected = ["processed_line1_with_testkey\n"]
+    assert processed_lines == expected
+
+
+def test_process_lines_multiple_workers():
+    """Testa a função process_lines"""
+    lines = ["line1", "line2", "line3"]
+    key = "testkey"
+    max_workers = 3
+    processed_lines = process_lines(
+        lines, key, mock_process_line_func, max_workers
+    )
+    expected = [
+        "processed_line1_with_testkey\n",
+        "processed_line2_with_testkey\n",
+        "processed_line3_with_testkey\n",
+    ]
+    assert processed_lines == expected
+
+
+def test_process_lines_order_preserved():
+    """Testa a função process_lines"""
+    lines = ["line1", "line2", "line3"]
+    key = "testkey"
+    max_workers = 2
+    processed_lines = process_lines(
+        lines, key, mock_process_line_func, max_workers
+    )
+    expected = [
+        "processed_line1_with_testkey\n",
+        "processed_line2_with_testkey\n",
+        "processed_line3_with_testkey\n",
+    ]
+    assert processed_lines == expected
+
+
+def test_process_lines_invalid_return_type():
+    """Testa a função process_lines"""
+    lines = ["line1"]
+    key = "testkey"
+    max_workers = 1
+    with pytest.raises(TypeError):
+        process_lines(lines, key, mock_process_line_func_invalid, max_workers)
+
+
+def test_process_lines_processing_exception():
+    """Testa a função process_lines"""
+    lines = ["line1"]
+    key = "testkey"
+    max_workers = 1
+    with pytest.raises(ValueError, match="Simulated processing error"):
+        process_lines(
+            lines, key, mock_process_line_func_exception, max_workers
+        )
+
+
+def test_process_lines_with_encryption():
+    """Testa a função process_lines"""
+    lines = ["hello", "world"]
+    key = "password"
+    max_workers = 2
+    processed_lines = process_lines(lines, key, encrypt, max_workers)
+
+    # Verifica se ambas as linhas foram processadas
+    assert len(processed_lines) == 2
+
+    # Verifica se todas as linhas são strings
+    assert all(isinstance(line, str) for line in processed_lines)
+
+
+def test_process_lines_with_decryption():
+    """Testa a função process_lines"""
+    encrypted_lines = [
+        encrypt("hello", "password"),
+        encrypt("world", "password"),
+    ]
+    key = "password"
+    max_workers = 2
+    processed_lines = process_lines(encrypted_lines, key, decrypt, max_workers)
+    expected = ["hello\n", "world\n"]
+    assert processed_lines == expected
diff --git a/tests/test_read_file.py b/tests/test_read_file.py
index 6d6dbac..f5140a7 100644
--- a/tests/test_read_file.py
+++ b/tests/test_read_file.py
@@ -8,7 +8,7 @@
 
 
 def teste_read_file_positive():
-    """Test function read_file"""
+    """Testando a função read_file"""
     file_name = "filte_test.txt"
     file_content = [
         "".join(sample(ascii_letters + digits, randint(1, 62))) + "\n"
diff --git a/tests/test_write_file.py b/tests/test_write_file.py
index 2e0fffe..3067c4c 100644
--- a/tests/test_write_file.py
+++ b/tests/test_write_file.py
@@ -8,7 +8,7 @@
 
 
 def teste_write_file_positive():
-    """Test function write_file"""
+    """Testando a função write_file"""
     file_name = "filte_test.txt"
     file_content = [
         "".join(sample(ascii_letters + digits, randint(1, 62))) + "\n"