Merge pull request #91 from unb-mds/66-melhorar-cobertura

Melhorar cobertura dos testes unitários

tests/test_info.empresa/test_carregamento_contratos.py

@@ -1,22 +1,72 @@
 import pytest
 import json
+import os
+import platform
+from unittest import mock
 from Dados.info_empresa import carregar_dados_json
 
-def test_carregar_dados_json(tmp_path):
-    # Cria um conteúdo JSON de teste
+
+def test_carregar_dados_json_valido(tmp_path):
     dados_teste = [
         {"Código": "123", "Empresas Contratadas": {"Empresa Contratada -1": "Empresa A", "CNPJ -1": "00.000.000/0001-00"}}
     ]
-
-#Cria um arquivo JSON temporário usando pytest
     caminho_arquivo_json = tmp_path / "contratos_teste.json"
     with caminho_arquivo_json.open("w", encoding="utf-8") as file:
         json.dump(dados_teste, file)
 
-#Executa a função e verifica se os dados carregados são os esperados
     dados_carregados = carregar_dados_json(caminho_arquivo_json)
     assert dados_carregados == dados_teste
 
-    # Testa se uma exceção é levantada ao tentar carregar um arquivo inexistente
-   # with pytest.raises(FileNotFoundError):
-    #    carregar_dados_json("caminho_inexistente.json")
+def test_carregar_dados_json_arquivo_inexistente():
+    with pytest.raises(FileNotFoundError):
+        carregar_dados_json("caminho_inexistente.json")
+
+def test_carregar_dados_json_malformado(tmp_path):
+    caminho_arquivo_json = tmp_path / "contratos_malformado.json"
+    with caminho_arquivo_json.open("w", encoding="utf-8") as file:
+        file.write("{'Código': '123', 'Empresas Contratadas': 'Empresa A'}")
+
+    with pytest.raises(json.JSONDecodeError):
+        carregar_dados_json(caminho_arquivo_json)
+
+def test_carregar_dados_json_vazio(tmp_path):
+    caminho_arquivo_json = tmp_path / "contratos_vazio.json"
+    caminho_arquivo_json.touch()  # Cria um arquivo vazio
+
+    with pytest.raises(json.JSONDecodeError):
+        carregar_dados_json(caminho_arquivo_json)
+
+def test_carregar_dados_json_estrutura_incorreta(tmp_path):
+    dados_teste = {"Código": "123"}  # Estrutura inesperada (falta chave "Empresas Contratadas")
+    caminho_arquivo_json = tmp_path / "contratos_incorreto.json"
+    with caminho_arquivo_json.open("w", encoding="utf-8") as file:
+        json.dump(dados_teste, file)
+
+    dados_carregados = carregar_dados_json(caminho_arquivo_json)
+    assert dados_carregados == dados_teste  # Pode mudar dependendo do que a função deve fazer
+
+def test_carregar_dados_json_permissao_negada(tmp_path):
+    dados_teste = [{"Código": "123"}]
+    caminho_arquivo_json = tmp_path / "contratos_permissao.json"
+    with caminho_arquivo_json.open("w", encoding="utf-8") as file:
+        json.dump(dados_teste, file)
+
+    # Simula o PermissionError usando mock na função open
+    with mock.patch("builtins.open", side_effect=PermissionError):
+        with pytest.raises(PermissionError):
+            carregar_dados_json(caminho_arquivo_json)
+
+def test_carregar_dados_json_none():
+    with pytest.raises(TypeError):
+        carregar_dados_json(None)
+
+def test_carregar_dados_json_codificacao_diferente(tmp_path):
+    dados_teste = [
+        {"Código": "123", "Empresas Contratadas": {"Empresa Contratada -1": "Empresa A", "CNPJ -1": "00.000.000/0001-00"}}
+    ]
+    caminho_arquivo_json = tmp_path / "contratos_utf16.json"
+    with caminho_arquivo_json.open("w", encoding="utf-16") as file:
+        json.dump(dados_teste, file)
+
+    with pytest.raises(UnicodeDecodeError):
+        carregar_dados_json(caminho_arquivo_json)

tests/test_info.empresa/test_processar_contratatos.py

@@ -1,44 +1,96 @@
 import pytest
 from Dados.info_empresa import processar_contratos
 
-def test_processar_contratos():
-    # Dados fictícios para simular a entrada
+def test_processar_contratos_dados_incompletos():
+    # Testa com dados incompletos, onde o CNPJ está faltando
     dados_teste = [
-        {   
+        {
             "Código": "123456",
             "Empresas Contratadas": {
                 "Empresa Contratada -1": "Empresa Teste A",
-                "CNPJ -1": "12.345.678/0001-00",
+                # "CNPJ -1" está faltando
                 "Valor Recebido -1": "10000.00",
-                "Descrição -1": "Serviços prestados",
-                "Empresa Contratada -2": "Empresa Teste B",
-                "CNPJ -2": "98.765.432/0001-99",
-                "Valor Recebido -2": "20000.00",
-                "Descrição -2": "Fornecimento de produtos"
+                "Descrição -1": "Serviços prestados"
             }
         }
     ]
+    # Verifica se um KeyError é levantado quando o CNPJ está faltando
+    with pytest.raises(KeyError, match="CNPJ -1"):
+        processar_contratos(dados_teste)
+
+
+def test_processar_contratos_formato_incorreto():
+    # Testa com dados em formato incorreto para o Valor Recebido
+    dados_teste = [
+        {
+            "Código": "123456",
+            "Empresas Contratadas": {
+                "Empresa Contratada -1": "Empresa Teste A",
+                "CNPJ -1": "12.345.678/0001-00",
+                "Valor Recebido -1": "dez mil",  # Formato incorreto
+                "Descrição -1": "Serviços prestados"
+            }
+        }
+    ]
+
+    # Tenta processar os contratos e verifica se o valor recebido está em formato incorreto
+    resultado_obtido = processar_contratos(dados_teste)
 
-    # Resultado esperado após processar os contratos
-    resultado_esperado = [
+    # Verifica se ocorre um ValueError quando o valor recebido não pode ser convertido para float
+    for item in resultado_obtido:
+        with pytest.raises(ValueError, match="could not convert string to float: 'dez mil'"):
+            float(item["Valor Recebido"])
+
+def test_processar_contratos_valor_recebido_faltando():
+    # Testa com dados onde o Valor Recebido está faltando
+    dados_teste = [
         {
             "Código": "123456",
-            "Empresa Contratada": "Empresa Teste A",
-            "CNPJ": "12.345.678/0001-00",
-            "Valor Recebido": "10000.00",
-            "Descrição": "Serviços prestados"
-        },
+            "Empresas Contratadas": {
+                "Empresa Contratada -1": "Empresa Teste A",
+                "CNPJ -1": "12.345.678/0001-00",
+                # "Valor Recebido -1" está faltando
+                "Descrição -1": "Serviços prestados"
+            }
+        }
+    ]
+    # Verifica se um KeyError é levantado quando o Valor Recebido está faltando
+    with pytest.raises(KeyError, match="Valor Recebido -1"):
+        processar_contratos(dados_teste)
+
+def test_processar_contratos_descricao_faltando():
+    # Testa com dados onde a Descrição está faltando
+    dados_teste = [
         {
             "Código": "123456",
-            "Empresa Contratada": "Empresa Teste B",
-            "CNPJ": "98.765.432/0001-99",
-            "Valor Recebido": "20000.00",
-            "Descrição": "Fornecimento de produtos"
+            "Empresas Contratadas": {
+                "Empresa Contratada -1": "Empresa Teste A",
+                "CNPJ -1": "12.345.678/0001-00",
+                "Valor Recebido -1": "10000.00"
+                # "Descrição -1" está faltando
+            }
         }
     ]
-
-    # Executa a função
+    # Verifica se um KeyError é levantado quando a Descrição está faltando
+    with pytest.raises(KeyError, match="Descrição -1"):
+        processar_contratos(dados_teste)
+
+def test_processar_contratos_valores_numericos():
+    # Testa com dados onde os valores são numericamente corretos
+    dados_teste = [
+        {
+            "Código": "123456",
+            "Empresas Contratadas": {
+                "Empresa Contratada -1": "Empresa Teste A",
+                "CNPJ -1": "12.345.678/0001-00",
+                "Valor Recebido -1": "10000.00",
+                "Descrição -1": "Serviços prestados"
+            }
+        }
+    ]
+    # Processa os contratos e verifica se os valores numéricos estão corretos
     resultado_obtido = processar_contratos(dados_teste)
 
-    # Verifica se o resultado obtido é igual ao esperado
-    assert resultado_obtido == resultado_esperado
+    # Converte os valores recebidos para float e verifica se não ocorre erro
+    for item in resultado_obtido:
+        assert float(item["Valor Recebido"]) == 10000.00

tests/test_info.empresa/test_salvamento_contratos.py

@@ -1,6 +1,7 @@
 import pytest
 import os
 import pandas as pd
+import warnings
 from Dados.info_empresa import salvar_em_csv
 
 def test_salvar_em_csv(tmp_path):
@@ -37,4 +38,93 @@ def test_salvar_em_csv(tmp_path):
     # Verifica se os dados no CSV são os esperados
     df_esperado = pd.DataFrame(dados_teste)
 
-    pd.testing.assert_frame_equal(df, df_esperado)
+    pd.testing.assert_frame_equal(df, df_esperado)
+
+# Novos testes para aumentar a cobertura
+
+def test_salvar_em_csv_sem_dados(tmp_path):
+    # Testa o salvamento com uma lista vazia de dados
+    dados_teste = []
+
+    caminho_arquivo_csv = tmp_path / "empresas_contratadas_vazio.csv"
+    caminho_absoluto_csv = salvar_em_csv(dados_teste, caminho_arquivo_csv)
+
+    assert os.path.exists(caminho_absoluto_csv)
+
+    # Verifica se o arquivo CSV gerado está vazio
+    with open(caminho_absoluto_csv, 'r') as file:
+        conteudo = file.read()
+        assert conteudo.strip() == ""  # O arquivo deve estar vazio
+
+@pytest.mark.filterwarnings("ignore:Mismatched null-like values nan and None found:FutureWarning")
+def test_salvar_em_csv_dados_nulos(tmp_path):
+    # Testa o salvamento com dados contendo valores nulos
+    dados_teste = [
+        {
+            "Código": "123456",
+            "Empresa Contratada": "Empresa Teste A",
+            "CNPJ": None,
+            "Valor Recebido": "10000.00",
+            "Descrição": None
+        }
+    ]
+
+    caminho_arquivo_csv = tmp_path / "empresas_contratadas_nulos.csv"
+    caminho_absoluto_csv = salvar_em_csv(dados_teste, caminho_arquivo_csv)
+
+    assert os.path.exists(caminho_absoluto_csv)
+
+    # Carrega o CSV e força o tipo 'object' para todas as colunas
+    df = pd.read_csv(caminho_absoluto_csv, dtype=str)
+
+    # Converte a coluna CNPJ e Descrição para 'object' explicitamente
+    df_esperado = pd.DataFrame(dados_teste).astype({"CNPJ": "object", "Descrição": "object"})
+
+    pd.testing.assert_frame_equal(df, df_esperado)
+
+
+def test_salvar_em_csv_tipo_incorreto(tmp_path):
+    # Testa o salvamento com um dado do tipo incorreto
+    dados_teste = [
+        {
+            "Código": 123456,  # Código como inteiro ao invés de string
+            "Empresa Contratada": "Empresa Teste A",
+            "CNPJ": "12.345.678/0001-00",
+            "Valor Recebido": "10000.00",
+            "Descrição": "Serviços prestados"
+        }
+    ]
+
+    caminho_arquivo_csv = tmp_path / "empresas_contratadas_tipo_incorreto.csv"
+    caminho_absoluto_csv = salvar_em_csv(dados_teste, caminho_arquivo_csv)
+
+    assert os.path.exists(caminho_absoluto_csv)
+
+    # Verifica se os dados no CSV são os esperados, corrigindo automaticamente o tipo de "Código"
+    df = pd.read_csv(caminho_absoluto_csv, dtype={"Código": str, "Valor Recebido": str})
+
+    # Corrige o tipo de dado esperado para a comparação
+    df_esperado = pd.DataFrame(dados_teste)
+    df_esperado["Código"] = df_esperado["Código"].astype(str)
+
+    pd.testing.assert_frame_equal(df, df_esperado)
+
+def test_salvar_em_csv_permissoes_arquivo(tmp_path):
+    # Testa o comportamento quando o arquivo CSV não pode ser escrito devido a permissões
+    dados_teste = [
+        {
+            "Código": "123456",
+            "Empresa Contratada": "Empresa Teste A",
+            "CNPJ": "12.345.678/0001-00",
+            "Valor Recebido": "10000.00",
+            "Descrição": "Serviços prestados"
+        }
+    ]
+
+    # Cria um arquivo e remove permissões de escrita
+    caminho_arquivo_csv = tmp_path / "empresas_contratadas_sem_permissao.csv"
+    caminho_arquivo_csv.touch(0o444)  # Permissões de leitura somente
+
+    # Tenta salvar no arquivo sem permissões e verifica se uma exceção é lançada
+    with pytest.raises(PermissionError):
+        salvar_em_csv(dados_teste, caminho_arquivo_csv)