test: teste unitario

Teste unitario receber recibo de tramite; Correção teste buscar estrutura

src/rn/ProcessoEletronicoRN.php

@@ -269,7 +269,7 @@ public function consultarEstrutura($idRepositorioEstrutura, $numeroDeIdentificac
           }
         }
 
-        return self::converterArrayParaObjeto($arrResultado);
+        return $this->converterArrayParaObjeto($arrResultado);
       }
 
         $objEstruturaDTO = new EstruturaDTO();
@@ -2740,12 +2740,12 @@ public function listarAssociacoesDocumentos($idProcedimento)
     /**
      * Converter arrays associativo para objetos
     */
-  public static function converterArrayParaObjeto($array) 
+  public function converterArrayParaObjeto($array) 
     {
     if (is_array($array)) {
         $object = new stdClass();
       foreach ($array as $key => $value) {
-        $object->$key = self::converterArrayParaObjeto($value);
+        $object->$key = $this->converterArrayParaObjeto($value);
       }
         return $object;
     }

tests_sei4/unitario/rn/ProcessoEletronicoRN/BuscarEstruturaTest.php

@@ -4,70 +4,137 @@
 
 /**
  * Classe de teste para o método buscarEstrutura da classe ProcessoEletronicoRN.
- * 
- * Esta classe utiliza PHPUnit para verificar o comportamento do método buscarEstrutura
- * em diferentes cenários, garantindo que ele funcione conforme o esperado.
+ *
+ * Esta classe utiliza o PHPUnit para verificar o comportamento do método
+ * `buscarEstrutura` em diferentes cenários, simulando respostas e verificando 
+ * exceções e resultados esperados.
  */
 class BuscarEstruturaTest extends TestCase
 {
-    /**
-     * Mock da classe ProcessoEletronicoRN.
-     * 
-     * @var ProcessoEletronicoRN|\PHPUnit\Framework\MockObject\MockObject
-     */
-    private $mockService;
+  /**
+   * Mock da classe ProcessoEletronicoRN.
+   *
+   * Este mock é utilizado para simular comportamentos específicos da classe 
+   * ProcessoEletronicoRN, evitando a execução de implementações reais e 
+   * focando no teste do método buscarEstrutura.
+   *
+   * @var ProcessoEletronicoRN|\PHPUnit\Framework\MockObject\MockObject
+   */
+  private $mockService;
 
-    /**
-     * Configuração inicial do teste.
-     * 
-     * Este método cria um mock da classe ProcessoEletronicoRN e redefine
-     * o método 'get' para simular comportamentos durante os testes.
-     *
-     * @return void
-     */
-    protected function setUp(): void
-    {
-        $this->mockService = $this->getMockBuilder(ProcessoEletronicoRN::class)
-                                  ->onlyMethods(['get'])
-                                  ->getMock();
-    }
+  /**
+   * Configuração inicial do teste.
+   *
+   * Este método configura o mock da classe ProcessoEletronicoRN, redefinindo 
+   * os métodos `get` e `buscarEstruturaRest` para possibilitar a simulação
+   * dos cenários de teste.
+   *
+   * @return void
+   */
+  protected function setUp(): void
+  {
+    $this->mockService = $this->getMockBuilder(ProcessoEletronicoRN::class)
+      ->onlyMethods(['get', 'buscarEstruturaRest'])
+      ->getMock();
+  }
 
-    public function testBuscarEstruturaSucesso()
-    {
-        $mockResponse = [
-            "numeroDeIdentificacaoDaEstrutura" => "157406",
-            "nome" => "CGPRO_PAUL_ORG1",
-            "sigla" => "CGPRO_PAUL_ORG1",
-            "ativo" => true,
-            "unidadeProtocolizadora" => false,
-            "unidadeReceptora" => false,
-            "aptoParaReceberTramites" => true,
-            "codigoNoOrgaoEntidade" => "",
-            "codigoUnidadeReceptora" => null,
-            "codigoUnidadeProtocolizadora" => null,
-            "tipoDeTramitacao" => 1,
-            "hierarquia" => []
-        ];
+  /**
+   * Testa o comportamento do método buscarEstrutura em caso de sucesso.
+   *
+   * Simula uma resposta válida para o método `buscarEstruturaRest` e verifica
+   * se o retorno do método testado é uma instância válida da classe EstruturaDTO.
+   *
+   * @return void
+   */
+  public function testBuscarEstruturaSucesso()
+  {
+    // Mock do retorno esperado da API
+    $estruturaMock = [
+      'numeroDeIdentificacaoDaEstrutura' => '12345',
+      'nome' => 'Estrutura Teste',
+      'sigla' => 'ET',
+      'ativo' => true,
+      'aptoParaReceber' => true,
+      'codigoNoOrgaoEntidade' => 'CNOE123',
+      'hierarquia' => [
+        ['sigla' => 'Nivel1'],
+        ['sigla' => 'Nivel2']
+      ]
+    ];
 
-        // Configura o mock para retornar a resposta
-        $this->mockService->expects($this->once())
-                          ->method('get')
-                          ->willReturn($mockResponse);
+    // Mock do método buscarEstruturaRest
+    $this->mockService->expects($this->once())
+      ->method('buscarEstruturaRest')
+      ->with(1, 'Estrutura Raiz')
+      ->willReturn($estruturaMock);
 
-        $resultado = $this->mockService->buscarEstrutura(5, 157406);
+    // Chamada do método
+    $resultado = $this->mockService->buscarEstrutura(
+      1, // idRepositorioEstrutura
+      'Estrutura Raiz' // Nome ou identificador raiz
+    );
 
-        $this->assertInstanceOf(EstruturaDTO::class, $resultado, 'O retorno deve ser uma instância da classe EstruturaDTO.');
-    }
+    $this->assertInstanceOf(EstruturaDTO::class, $resultado, 'O retorno deve ser uma instância da classe EstruturaDTO.');
+  }
 
-    public function testBuscarEstruturaLancaExcecao()
-    {
-        $this->mockService->expects($this->once())
-                          ->method('get')
-                          ->willThrowException(new Exception());
+  /**
+   * Testa o comportamento do método buscarEstrutura com um repositório inválido.
+   *
+   * Verifica se o método lança a exceção correta ao receber um ID de repositório inválido.
+   *
+   * @return void
+   */
+  public function testBuscarEstruturaComRepositorioInvalido()
+  {
+    $this->expectException(InfraException::class);
+    $this->expectExceptionMessage('Falha na obtenção de unidades externas');
 
-        $this->expectException(InfraException::class);
-        $this->expectExceptionMessage('Falha na obtenção de unidades externas');
+    $this->mockService->buscarEstrutura(0); // Passando um ID inválido
+  }
 
-        $this->mockService->consultarEstrutura(159098, 152254, false);
-    }
+  /**
+   * Testa o comportamento do método buscarEstrutura quando a estrutura não é encontrada.
+   *
+   * Simula o retorno `null` do método `buscarEstruturaRest` e verifica se o
+   * método principal retorna `null` como esperado.
+   *
+   * @return void
+   */
+  public function testBuscarEstruturaNaoEncontrada()
+  {
+    // Mock para retorno nulo da API
+    $this->mockService->expects($this->once())
+      ->method('buscarEstruturaRest')
+      ->with(1, 'Estrutura Raiz')
+      ->willReturn(null);
+
+    // Chamada do método
+    $resultado = $this->mockService->buscarEstrutura(
+      1, // idRepositorioEstrutura
+      'Estrutura Raiz' // Nome ou identificador raiz
+    );
+
+    // Asserção de retorno nulo
+    $this->assertNull($resultado);
+  }
+
+  /**
+   * Testa o comportamento do método buscarEstrutura quando ocorre uma exceção.
+   *
+   * Simula uma exceção no método `get` e verifica se a exceção correta é lançada 
+   * pelo método testado.
+   *
+   * @return void
+   */
+  public function testBuscarEstruturaLancaExcecao()
+  {
+    $this->mockService->expects($this->once())
+      ->method('get')
+      ->willThrowException(new Exception());
+
+    $this->expectException(InfraException::class);
+    $this->expectExceptionMessage('Falha na obtenção de unidades externas');
+
+    $this->mockService->consultarEstrutura(159098, 152254, false);
+  }
 }

tests_sei4/unitario/rn/ProcessoEletronicoRN/ReceberReciboDeTramiteTest.php

@@ -0,0 +1,103 @@
+<?php
+
+use PHPUnit\Framework\TestCase;
+
+/**
+ * Classe de teste para o método de recebimento de recibo de trâmite.
+ *
+ * Esta classe realiza testes unitários para métodos relacionados ao 
+ * recebimento de recibos de trâmite utilizando mocks para simular 
+ * dependências e comportamento.
+ */
+class ReceberReciboDeTramiteTest extends TestCase
+{
+  /**
+   * Mock da classe ProcessoEletronicoRN.
+   *
+   * Este mock é usado para simular os comportamentos da classe sem executar
+   * a implementação real, permitindo testar os métodos que dependem dela.
+   *
+   * @var ProcessoEletronicoRN|\PHPUnit\Framework\MockObject\MockObject
+   */
+  private $mockService;
+
+  /**
+   * Configuração inicial antes de cada teste.
+   *
+   * Este método cria o mock de ProcessoEletronicoRN e define quais métodos
+   * podem ser simulados.
+   *
+   * @return void
+   */
+  protected function setUp(): void
+  {
+    $this->mockService = $this->getMockBuilder(ProcessoEletronicoRN::class)
+      ->onlyMethods(['get', 'converterArrayParaObjeto'])
+      ->getMock();
+  }
+
+  /**
+   * Testa o recebimento de recibo de trâmite com sucesso.
+   *
+   * Simula a execução do método `get` e o retorno de um objeto 
+   * convertido a partir de um array, verificando se o resultado 
+   * final corresponde ao esperado.
+   *
+   * @return void
+   */
+  public function testReceberReciboDeTramiteComSucesso()
+  {
+    // Mock do retorno esperado do método get
+    $resultadoMock = [
+      'recibo' => [
+        'hashesDosComponentesDigitais' => ['hash123'],
+        'outroDado' => 'valor'
+      ]
+    ];
+
+    $this->mockService->expects($this->once())
+      ->method('get')
+      ->willReturn($resultadoMock);
+
+    // Substituir o método estático converterArrayParaObjeto
+    $resultadoObjetoMock = (object)[
+      'recibo' => (object)[
+        'hashDoComponenteDigital' => 'hash123',
+        'outroDado' => 'valor'
+      ]
+    ];
+
+    $this->mockService->expects($this->once())
+      ->method('converterArrayParaObjeto')
+      ->willReturn($resultadoObjetoMock);
+
+    // Chamada do método
+    $resultado = $this->mockService->receberReciboDeTramite(123);
+
+    // Asserções
+    $this->assertIsObject($resultado);
+    $this->assertEquals('hash123', $resultado->recibo->hashDoComponenteDigital);
+    $this->assertEquals('valor', $resultado->recibo->outroDado);
+  }
+
+  /**
+   * Testa o cenário em que ocorre um erro ao receber o recibo de trâmite.
+   *
+   * Simula uma exceção no método `get` e verifica se a exceção correta é
+   * lançada pelo método testado.
+   *
+   * @return void
+   */
+  public function testReceberReciboDeTramiteComErro()
+  {
+    $this->mockService->expects($this->once())
+      ->method('get')
+      ->willThrowException(new Exception('Erro simulado'));
+
+    // Verifica se a exceção esperada é lançada
+    $this->expectException(InfraException::class);
+    $this->expectExceptionMessage('Falha no recebimento de recibo de trâmite.');
+
+    $this->mockService->receberReciboDeTramite(123);
+  }
+}