protoncloud-sdk 5.2.0__tar.gz → 5.3.0__tar.gz

{protoncloud_sdk-5.2.0 → protoncloud_sdk-5.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: protoncloud-sdk
-Version: 5.2.0
+Version: 5.3.0
 Summary: Proton Cloud SDK para Python: execução de automações, ambientes, logs, parâmetros e recursos.
 Project-URL: Homepage, https://protoncloud.com.br
 Author: Atomic Solutions
@@ -16,7 +16,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Software Development :: Testing
 Requires-Python: >=3.10
-Requires-Dist: requests>=2.31
+Requires-Dist: requests>=2.32.4
 Description-Content-Type: text/markdown
 
 # Proton Cloud SDK (Python)
@@ -265,6 +265,53 @@ no lugar do último, com um `DeprecationWarning` e uma linha `[proton]` no log n
 primeira vez. Para separar falha de dados de falha de ambiente, registre o
 motivo no log da execução.
 
+## Executor de componentes
+
+Desde a 5.3.0 a SDK traz o laço que roda os passos do dataset, que antes cada
+projeto copiava no `tests/test_proton_script.py`. O projeto só diz, pelo nome do
+componente cadastrado no Proton, qual função executar:
+
+```python
+# tests/test_proton_script.py: o único arquivo do projeto que importa a SDK
+from proton.component_runner import run_components
+from automacao.passos import localizar
+
+
+def test_run_proton_execution():
+    run_components(localizar)
+```
+
+`localizar` recebe o nome do componente e devolve o passo: uma função que recebe
+os parâmetros (`dict`) e devolve as saídas (`dict` ou `None`). Também serve um
+`dict` de nome para função. O código de negócio não importa nada do Proton e roda
+igual fora dele.
+
+A cada passo, o executor:
+
+- marca o início e o fim, inclusive quando o passo falha;
+- passa só os parâmetros daquele passo, já resolvidos pelo Proton (variável,
+  referência a saída, valor digitado no disparo, criptografado);
+- grava as saídas devolvidas. Uma saída que não está cadastrada como parâmetro do
+  passo vira aviso no log;
+- sobe o que apareceu na pasta `evidencias/` durante o passo: imagens no passo, o
+  resto na execução (`evidence_dir` muda a pasta; `None` desliga);
+- manda para a execução o que o projeto registra pelo `logging`, do nível INFO
+  para cima (`forward_logs=False` desliga).
+
+No fim, grava `PASSED` quando não sobra passo. Quando um passo falha, grava o
+stack trace no painel de erro, grava `FAILED` e relança a exceção. Execução parada
+não recebe status por cima.
+
+Um projeto pode cuidar de várias plataformas (SAP, web, API, desktop), cada uma
+cadastrada como um sistema no Proton e todas ligadas ao mesmo repositório: o executor
+segue no mesmo processo enquanto o projeto tiver o componente do próximo passo, e as
+sessões abertas continuam valendo. Quando o projeto não tem o componente e o passo é de
+outro sistema, o executor devolve o controle ao runner, que chama o projeto daquele
+sistema.
+
+Fora de uma execução do Proton, `run_components` lança `ProtonRunError` em vez de
+chamar o servidor.
+
 ## Migrando de uma cópia local da pasta `proton/`
 
 Projetos que carregam esta biblioteca como uma pasta `proton/` copiada migram em

{protoncloud_sdk-5.2.0 → protoncloud_sdk-5.3.0}/README.md

@@ -244,6 +244,53 @@ no lugar do último, com um `DeprecationWarning` e uma linha `[proton]` no log n
 primeira vez. Para separar falha de dados de falha de ambiente, registre o
 motivo no log da execução.
 
+## Executor de componentes
+
+Desde a 5.3.0 a SDK traz o laço que roda os passos do dataset, que antes cada
+projeto copiava no `tests/test_proton_script.py`. O projeto só diz, pelo nome do
+componente cadastrado no Proton, qual função executar:
+
+```python
+# tests/test_proton_script.py: o único arquivo do projeto que importa a SDK
+from proton.component_runner import run_components
+from automacao.passos import localizar
+
+
+def test_run_proton_execution():
+    run_components(localizar)
+```
+
+`localizar` recebe o nome do componente e devolve o passo: uma função que recebe
+os parâmetros (`dict`) e devolve as saídas (`dict` ou `None`). Também serve um
+`dict` de nome para função. O código de negócio não importa nada do Proton e roda
+igual fora dele.
+
+A cada passo, o executor:
+
+- marca o início e o fim, inclusive quando o passo falha;
+- passa só os parâmetros daquele passo, já resolvidos pelo Proton (variável,
+  referência a saída, valor digitado no disparo, criptografado);
+- grava as saídas devolvidas. Uma saída que não está cadastrada como parâmetro do
+  passo vira aviso no log;
+- sobe o que apareceu na pasta `evidencias/` durante o passo: imagens no passo, o
+  resto na execução (`evidence_dir` muda a pasta; `None` desliga);
+- manda para a execução o que o projeto registra pelo `logging`, do nível INFO
+  para cima (`forward_logs=False` desliga).
+
+No fim, grava `PASSED` quando não sobra passo. Quando um passo falha, grava o
+stack trace no painel de erro, grava `FAILED` e relança a exceção. Execução parada
+não recebe status por cima.
+
+Um projeto pode cuidar de várias plataformas (SAP, web, API, desktop), cada uma
+cadastrada como um sistema no Proton e todas ligadas ao mesmo repositório: o executor
+segue no mesmo processo enquanto o projeto tiver o componente do próximo passo, e as
+sessões abertas continuam valendo. Quando o projeto não tem o componente e o passo é de
+outro sistema, o executor devolve o controle ao runner, que chama o projeto daquele
+sistema.
+
+Fora de uma execução do Proton, `run_components` lança `ProtonRunError` em vez de
+chamar o servidor.
+
 ## Migrando de uma cópia local da pasta `proton/`
 
 Projetos que carregam esta biblioteca como uma pasta `proton/` copiada migram em

{protoncloud_sdk-5.2.0 → protoncloud_sdk-5.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "protoncloud-sdk"
-version = "5.2.0"
+version = "5.3.0"
 description = "Proton Cloud SDK para Python: execução de automações, ambientes, logs, parâmetros e recursos."
 readme = "README.md"
 requires-python = ">=3.10"
@@ -21,7 +21,9 @@ classifiers = [
     "Programming Language :: Python :: 3.13",
     "Topic :: Software Development :: Testing",
 ]
-dependencies = ["requests>=2.31"]
+# Piso, e não versão fixa: biblioteca não prende quem a usa. A 2.32.4 é a primeira sem a
+# falha do .netrc (CVE-2024-47081), que podia mandar credencial ao host errado.
+dependencies = ["requests>=2.32.4"]
 
 # Sem link para o repositorio: ele e privado, e o link publicado no PyPI seria
 # um 404 para qualquer pessoa de fora.
@@ -43,7 +45,7 @@ packages = ["src/proton"]
 include = ["src/proton", "tests", "README.md", "LICENSE", "pyproject.toml"]
 
 [dependency-groups]
-dev = ["pytest>=8"]
+dev = ["pytest>=9.1.1"]
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]

protoncloud_sdk-5.3.0/src/proton/component_runner.py

@@ -0,0 +1,324 @@
+"""
+Executor de componentes: o laço que roda os passos do dataset numa execução do Proton.
+
+O projeto de automação entrega uma função que, pelo nome do componente cadastrado no
+Proton, devolve o passo a executar: uma função que recebe os parâmetros (`dict`) e
+devolve as saídas (`dict` ou `None`). O executor cuida do resto, igual em todo projeto:
+
+- marca o início e o fim de cada passo, inclusive quando ele falha;
+- passa ao passo só os parâmetros dele, já resolvidos pelo Proton;
+- grava as saídas que o passo devolve;
+- sobe as evidências que o passo deixou na pasta de evidências;
+- manda para a execução o que o projeto registra pelo `logging`;
+- grava o erro e o status uma vez só.
+
+Com isso o código de negócio não importa nada do Proton e roda igual fora dele. O
+único arquivo do projeto que conhece a SDK é o ponto de entrada do runner
+(`tests/test_proton_script.py`):
+
+    from proton.component_runner import run_components
+    from automacao.passos import localizar
+
+    def test_run_proton_execution():
+        run_components(localizar)
+
+Um projeto pode cuidar de várias plataformas (SAP, web, API, desktop), cada uma cadastrada
+como um sistema no Proton e todas ligadas ao mesmo repositório. O executor segue no mesmo
+processo enquanto o projeto tiver o componente do próximo passo, e as sessões abertas
+(navegador, SAP, aplicativo) continuam valendo. Quando o projeto não tem o componente e o
+passo é de outro sistema, ele devolve o controle ao runner sem gravar status, e o runner
+chama o projeto daquele sistema.
+"""
+
+import logging
+import threading
+import traceback
+from collections.abc import Mapping
+from pathlib import Path
+from typing import Callable, Optional, Union
+
+from proton import proton_automation, proton_files_and_resources, proton_logs, proton_parameter
+from proton.proton_env import is_proton_execution
+from proton.run_status import RunStatus
+
+Passo = Callable[[dict], Optional[Mapping]]
+"""Um passo: recebe os parâmetros do componente e devolve as saídas (ou `None`)."""
+
+Localizador = Union[Callable[[str], Optional[Passo]], Mapping]
+"""Do nome do componente no Proton ao passo: uma função ou um `dict`."""
+
+LIMITE_DE_PASSOS = 500
+"""Proteção contra laço: nenhuma execução real chega perto disso."""
+
+_IMAGENS = {".png", ".jpg", ".jpeg", ".gif", ".bmp", ".webp"}
+_STATUS_DE_PARADA = {"Stopped", "Cancelled"}
+
+logger = logging.getLogger("proton")
+
+
+class ProtonRunError(RuntimeError):
+    """Falha do executor, e não do passo: passo que não inicia, componente que não existe, laço."""
+
+
+class ProtonLogHandler(logging.Handler):
+    """Manda cada registro do `logging` para o log da execução no Proton."""
+
+    _PREFIXOS = {logging.WARNING: "Aviso: ", logging.ERROR: "Erro: ", logging.CRITICAL: "Erro: "}
+
+    def __init__(self, level=logging.INFO):
+        super().__init__(level)
+        self._enviando = threading.local()
+
+    def emit(self, record):
+        # O envio é uma requisição HTTP, e a biblioteca de HTTP também registra pelo
+        # `logging`: sem esta trava, um log em DEBUG geraria outro, sem fim.
+        if getattr(self._enviando, "ativo", False):
+            return
+
+        self._enviando.ativo = True
+        try:
+            proton_logs.set_log(self._PREFIXOS.get(record.levelno, "") + self.format(record))
+        except Exception:
+            self.handleError(record)
+        finally:
+            self._enviando.ativo = False
+
+
+def run_components(resolve: Localizador, *, evidence_dir: Optional[str] = "evidencias",
+                   forward_logs: bool = True, max_steps: int = LIMITE_DE_PASSOS) -> int:
+    """
+    Roda, na ordem do dataset, os passos da execução corrente.
+
+    Args:
+        resolve: função que recebe o nome do componente e devolve o passo, ou um `dict`
+            de nome para passo. O passo recebe os parâmetros e devolve as saídas.
+        evidence_dir: pasta onde o projeto grava prints e arquivos. O que aparecer nela
+            durante um passo sobe para o Proton: imagens no passo, o resto na execução.
+            `None` desliga o envio.
+        forward_logs: manda para a execução o que o projeto registra pelo `logging`
+            (nível INFO para cima) enquanto os passos rodam.
+        max_steps: limite de passos, contra laço infinito.
+
+    Returns:
+        int: quantos passos rodaram.
+
+    Raises:
+        ProtonRunError: fora de uma execução do Proton, ou quando o executor não consegue
+            seguir (passo que não inicia, componente que não existe, laço).
+        Exception: a exceção do passo que falhou, depois de gravada no Proton.
+    """
+    if not is_proton_execution():
+        raise ProtonRunError(
+            "run_components só roda numa execução do Proton: falta idDatasetRun no ambiente. "
+            "Fora do Proton, rode os cenários do projeto direto."
+        )
+
+    localizar = _localizador(resolve)
+    handler = _ligar_log() if forward_logs else None
+    executados = 0
+
+    try:
+        sistema = proton_automation.get_current_component_system()
+
+        if not sistema:
+            if _foi_parada():
+                return 0
+            raise ProtonRunError("A execução não tem passo pendente: nada para rodar.")
+
+        while True:
+            nome = proton_automation.get_current_component_name()
+
+            if not nome:
+                break
+
+            passo, erro_ao_localizar = _procurar(localizar, nome)
+
+            # O que decide se o passo roda aqui é o projeto ter o componente (o nome é único
+            # na organização), e não o sistema: um projeto pode cuidar de várias plataformas.
+            if passo is None and erro_ao_localizar is None:
+                proximo_sistema = proton_automation.get_current_component_system()
+
+                if proximo_sistema != sistema:
+                    logger.info('O componente "%s" (sistema "%s") não é deste projeto: o runner segue com o projeto dele.',
+                                nome, proximo_sistema)
+                    return executados
+
+            if executados >= max_steps:
+                raise ProtonRunError(f"Mais de {max_steps} passos na mesma execução: parei para não entrar em laço.")
+
+            _executar_passo(nome, passo, erro_ao_localizar, evidence_dir)
+            executados += 1
+
+        if _foi_parada():
+            return executados
+
+        proton_automation.update_run_status(RunStatus.PASSED)
+        return executados
+
+    except Exception as erro:
+        _registrar_falha(erro)
+        raise
+
+    finally:
+        if handler is not None:
+            _desligar_log(handler)
+
+
+def _localizador(resolve):
+    if isinstance(resolve, Mapping):
+        return resolve.get
+
+    if callable(resolve):
+        return resolve
+
+    raise TypeError("resolve deve ser uma função (nome -> passo) ou um dict de nome para passo.")
+
+
+def _procurar(localizar, nome):
+    """O passo do componente, ou o erro de quem o procurou (um import quebrado, por exemplo)."""
+    try:
+        return localizar(nome), None
+    except Exception as erro:
+        return None, erro
+
+
+def _executar_passo(nome, passo, erro_ao_localizar, evidence_dir):
+    progresso = proton_automation.start_component()
+
+    # Sem o início marcado, o Proton continuaria apontando para este mesmo passo, e o
+    # laço o rodaria de novo para sempre.
+    if not progresso:
+        raise ProtonRunError(f'O Proton não iniciou o passo "{nome}".')
+
+    antes = _arquivos(evidence_dir)
+
+    try:
+        logger.info("Passo %s: %s", progresso.get("order", "?"), nome)
+
+        # O erro de quem procurou o componente só sobe agora, com o passo marcado, para a
+        # linha do tempo da execução mostrar em qual passo foi.
+        if erro_ao_localizar is not None:
+            raise erro_ao_localizar
+
+        if passo is None:
+            raise ProtonRunError(f'O componente "{nome}" não existe no projeto.')
+
+        saidas = passo(_parametros_do_passo(progresso, nome))
+        _gravar_saidas(nome, saidas)
+
+    finally:
+        try:
+            _enviar_evidencias(evidence_dir, antes)
+        except Exception:
+            logger.exception("Falha ao enviar as evidências do passo %s", nome)
+
+        proton_automation.end_component()
+
+
+def _parametros_do_passo(progresso, nome):
+    """
+    Só os parâmetros do passo que está rodando, com os valores já resolvidos pelo Proton
+    (variável, referência a saída, valor digitado no disparo, criptografado).
+
+    A rota devolve todos os passos do dataset; o passo corrente é o de mesma ordem que o
+    `start-component` devolveu. Pela ordem, e não pelo nome, porque o mesmo componente
+    pode aparecer duas vezes no dataset com parâmetros diferentes.
+    """
+    componentes = proton_parameter.get_proton_all_component_parameters()
+
+    if not isinstance(componentes, list):
+        return {}
+
+    ordem = progresso.get("order")
+    candidatos = [c for c in componentes if c.get("order") == ordem]
+    escolhido = next((c for c in candidatos if c.get("component") == nome), None)
+
+    if escolhido is None:
+        escolhido = next((c for c in componentes if c.get("component") == nome), None)
+
+    if escolhido is None:
+        return {}
+
+    return {
+        p["parameter"]: "" if p.get("value") is None else str(p["value"])
+        for p in escolhido.get("params") or []
+        if p.get("parameter")
+    }
+
+
+def _gravar_saidas(nome, saidas):
+    if saidas is None:
+        return
+
+    if not isinstance(saidas, Mapping):
+        raise ProtonRunError(
+            f'O componente "{nome}" devolveu {type(saidas).__name__}: o esperado é um dict com as saídas.'
+        )
+
+    for parametro, valor in saidas.items():
+        status = proton_parameter.set_proton_value(parametro, "" if valor is None else valor)
+
+        if status == 404:
+            logger.warning('A saída "%s" do componente "%s" não está no passo do dataset. '
+                           "Cadastre-a como parâmetro do passo para o Proton guardar o valor.", parametro, nome)
+
+
+def _arquivos(evidence_dir):
+    if not evidence_dir:
+        return {}
+
+    pasta = Path(evidence_dir)
+
+    if not pasta.is_dir():
+        return {}
+
+    return {arquivo: arquivo.stat().st_mtime_ns for arquivo in pasta.rglob("*") if arquivo.is_file()}
+
+
+def _enviar_evidencias(evidence_dir, antes):
+    """Sobe o que apareceu (ou mudou) na pasta de evidências durante o passo."""
+    for arquivo, modificado in sorted(_arquivos(evidence_dir).items(), key=lambda item: item[1]):
+        if antes.get(arquivo) == modificado:
+            continue
+
+        if arquivo.suffix.lower() in _IMAGENS:
+            proton_files_and_resources.upload_image(str(arquivo))
+        else:
+            proton_files_and_resources.upload_file_resource(str(arquivo))
+
+
+def _foi_parada():
+    """Execução parada ou cancelada por alguém: o executor não grava status por cima."""
+    return proton_automation.get_dataset_run_status() in _STATUS_DE_PARADA
+
+
+def _registrar_falha(erro):
+    try:
+        if _foi_parada():
+            return
+
+        proton_logs.set_error_log("".join(traceback.format_exception(type(erro), erro, erro.__traceback__)))
+        proton_automation.update_run_status(RunStatus.FAILED)
+    except Exception:
+        # A falha original é a que importa: um erro ao registrá-la não pode escondê-la.
+        logger.exception("Falha ao registrar o erro da execução no Proton")
+
+
+def _ligar_log():
+    handler = ProtonLogHandler()
+    handler.setFormatter(logging.Formatter("%(message)s"))
+    raiz = logging.getLogger()
+    handler._nivel_anterior = raiz.level
+
+    # O padrão do Python é WARNING, que esconderia o logging.info dos passos.
+    if raiz.level > logging.INFO:
+        raiz.setLevel(logging.INFO)
+
+    raiz.addHandler(handler)
+    return handler
+
+
+def _desligar_log(handler):
+    raiz = logging.getLogger()
+    raiz.removeHandler(handler)
+    raiz.setLevel(handler._nivel_anterior)

{protoncloud_sdk-5.2.0 → protoncloud_sdk-5.3.0}/src/proton/proton_environment.py

@@ -21,6 +21,7 @@ log da execução, e nunca trazem valores.
 """
 
 import re
+from urllib.parse import quote, quote_plus
 import threading
 
 import requests
@@ -86,8 +87,15 @@ class _Carga:
         self.error = error
 
         # Do mais longo para o mais curto: um valor que contém outro sai inteiro.
+        # Também as formas codificadas para URL: um valor que vai na query (a saída gravada
+        # pelo set_proton_value, por exemplo) aparece assim na URL e no eco do servidor.
         valores = sorted(
-            {valor for valor in self.variables.values() if len(valor) >= TAMANHO_MINIMO_PARA_MASCARAR},
+            {
+                variante
+                for valor in self.variables.values()
+                if len(valor) >= TAMANHO_MINIMO_PARA_MASCARAR
+                for variante in (valor, quote_plus(valor), quote(valor, safe=""))
+            },
             key=len,
             reverse=True,
         )

{protoncloud_sdk-5.2.0 → protoncloud_sdk-5.3.0}/src/proton/proton_git.py

@@ -1,11 +1,15 @@
+"""
+Consulta dos repositórios Git cadastrados no Proton.
+
+O clone de repositório saiu da SDK na 5.2.1: baixar o código é papel do runner, e o
+clone levava o token do GitHub na linha de comando.
+"""
+
 import os
-import subprocess
-import threading
 
 import requests
 from proton.proton_client_parama import ProtonClientParam
 from proton.proton_env import get_api_url, get_auth_header
-from proton.proton_logs import set_log
 
 
 def get_remote_repository(system_type):
@@ -62,27 +66,6 @@ def get_remote_header_hash(remote_authorization, repository, branch):
     else:
         return ""
 
-def clone_repository(owner_repo, branch, commit_hash, authorization):
-    """Clona um repositório Git."""
-    repo_folder = os.path.join(ProtonClientParam._repository_folder(), owner_repo, branch, commit_hash)
-    os.makedirs(repo_folder, exist_ok=True)
-
-    def run_git_clone(repo_folder, branch, authorization, owner_repo):
-        try:
-            url = f"https://{authorization}@github.com/{owner_repo}.git"
-            subprocess.run(
-                ["git", "clone", "--branch", branch, url], 
-                cwd=repo_folder,
-                check=True,  # Levanta exceção se o git retornar código de erro
-                capture_output=True,   # Captura o output 
-                text=True  
-            )
-        except subprocess.CalledProcessError as e:
-            set_log(f"Erro ao clonar: {e.output}") 
-
-    thread = threading.Thread(target=run_git_clone, args=(repo_folder, branch, authorization, owner_repo))
-    thread.start()
-
 def get_local_repository_path(owner_repo, repository, branch, commit_hash):
     """Retorna o caminho para um repositório local."""
     repo_folder = os.path.join(ProtonClientParam._repository_folder(), owner_repo, branch, commit_hash, repository)

{protoncloud_sdk-5.2.0 → protoncloud_sdk-5.3.0}/src/proton/proton_parameter.py

@@ -1,3 +1,5 @@
+from urllib.parse import quote_plus
+
 import requests
 from proton.proton_env import get_auth_header, get_host, get_id_dataset_run, is_proton_execution
 from proton.proton_environment import mask_environment_values
@@ -16,11 +18,14 @@ def set_proton_value(param, value):
         value (str ou int): O valor a ser inserido no parâmetro de output.
     """
     if is_proton_execution():
+        # O backend decodifica o valor de novo depois de ler a query (troca "+" por espaço
+        # e aplica decodeURIComponent), como a SDK Java espera: ela codifica o valor antes
+        # de montar a URL. Mandando o valor cru, um "+" virava espaço e um "%" derrubava a
+        # gravação com HTTP 500.
         params = {
-            "parameter": param
+            "parameter": param,
+            "value": quote_plus(str(value)),
         }
-        
-        params["value"] = str(value)
 
         # Proton 5: a rota e "/set-value"; "/setValue" (Proton 4) responde 404 e o valor nunca era gravado.
         response = requests.put(f"{_get_dataset_run_url()}/set-value", params=params, headers=get_auth_header())

protoncloud_sdk-5.3.0/tests/test_component_runner.py

@@ -0,0 +1,324 @@
+"""
+Executor de componentes: o laço que todo projeto copiava (TestProtonScript) agora vive na
+SDK. Os testes simulam o Proton com os passos de uma execução e conferem o contrato:
+início e fim de cada passo, parâmetros só do passo, saídas, evidências, log, erro e status.
+"""
+
+import logging
+
+import pytest
+
+from proton import component_runner, proton_automation, proton_files_and_resources, proton_logs, proton_parameter
+from proton.component_runner import ProtonRunError, run_components
+from proton.run_status import RunStatus
+
+
+class ProtonFalso:
+    """A execução no Proton: passos com sistema, ordem e parâmetros, e o que a SDK gravou."""
+
+    def __init__(self, passos):
+        self.passos = passos
+        self.atual = 0
+        self.aberto = None
+        self.status = "Running"
+        self.chamadas = []
+        self.saidas = []
+        self.logs = []
+        self.erros = []
+        self.imagens = []
+        self.arquivos = []
+        self.saidas_fora_do_passo = set()
+        self.inicio_falha = False
+
+    def _pendente(self):
+        return self.passos[self.atual] if self.atual < len(self.passos) else None
+
+    def nome(self):
+        passo = self._pendente()
+        return passo["nome"] if passo else ""
+
+    def sistema(self):
+        passo = self._pendente()
+        return passo.get("sistema", "Web") if passo else ""
+
+    def iniciar(self):
+        self.chamadas.append("start")
+        passo = self._pendente()
+
+        if self.inicio_falha or passo is None:
+            return {}
+
+        self.aberto = passo
+        self.atual += 1
+        return {"id": 100 + self.atual, "order": passo["ordem"], "component": passo["nome"]}
+
+    def finalizar(self):
+        self.chamadas.append("end")
+        self.aberto = None
+        return 2
+
+    def parametros(self):
+        return [
+            {"component": p["nome"], "order": p["ordem"],
+             "params": [{"parameter": k, "value": v} for k, v in p.get("parametros", {}).items()]}
+            for p in self.passos
+        ]
+
+    def gravar_saida(self, parametro, valor):
+        if parametro in self.saidas_fora_do_passo:
+            return 404
+
+        self.saidas.append((self.aberto["nome"], parametro, valor))
+        return 200
+
+    def atualizar_status(self, status):
+        self.status = status.value
+
+
+@pytest.fixture
+def proton(monkeypatch):
+    monkeypatch.setenv("idDatasetRun", "42")
+
+    def montar(passos):
+        falso = ProtonFalso(passos)
+        monkeypatch.setattr(proton_automation, "get_current_component_name", falso.nome)
+        monkeypatch.setattr(proton_automation, "get_current_component_system", falso.sistema)
+        monkeypatch.setattr(proton_automation, "start_component", falso.iniciar)
+        monkeypatch.setattr(proton_automation, "end_component", falso.finalizar)
+        monkeypatch.setattr(proton_automation, "update_run_status", falso.atualizar_status)
+        monkeypatch.setattr(proton_automation, "get_dataset_run_status", lambda *a: falso.status)
+        monkeypatch.setattr(proton_parameter, "get_proton_all_component_parameters", falso.parametros)
+        monkeypatch.setattr(proton_parameter, "set_proton_value", falso.gravar_saida)
+        monkeypatch.setattr(proton_logs, "set_log", falso.logs.append)
+        monkeypatch.setattr(proton_logs, "set_error_log", falso.erros.append)
+        monkeypatch.setattr(proton_files_and_resources, "upload_image", falso.imagens.append)
+        monkeypatch.setattr(proton_files_and_resources, "upload_file_resource", falso.arquivos.append)
+        return falso
+
+    return montar
+
+
+def test_roda_os_passos_na_ordem_com_os_parametros_de_cada_um(proton):
+    falso = proton([
+        {"nome": "FazerLogin", "ordem": 1, "parametros": {"in_usuario": "ana"}},
+        {"nome": "AdicionarAoCarrinho", "ordem": 2, "parametros": {"in_produto": "Mochila", "out_preco": None}},
+    ])
+    recebidos = []
+
+    def passo(nome, saidas=None):
+        def executar(params):
+            recebidos.append((nome, params))
+            return saidas
+        return executar
+
+    executados = run_components({
+        "FazerLogin": passo("FazerLogin"),
+        "AdicionarAoCarrinho": passo("AdicionarAoCarrinho", {"out_preco": "29.99"}),
+    })
+
+    assert executados == 2
+    assert recebidos == [
+        ("FazerLogin", {"in_usuario": "ana"}),
+        ("AdicionarAoCarrinho", {"in_produto": "Mochila", "out_preco": ""}),
+    ]
+    assert falso.chamadas == ["start", "end", "start", "end"]
+    assert falso.saidas == [("AdicionarAoCarrinho", "out_preco", "29.99")]
+    assert falso.status == RunStatus.PASSED.value
+
+
+def test_o_mesmo_componente_duas_vezes_recebe_os_parametros_da_sua_posicao(proton):
+    proton([
+        {"nome": "AdicionarAoCarrinho", "ordem": 1, "parametros": {"in_produto": "Mochila"}},
+        {"nome": "AdicionarAoCarrinho", "ordem": 2, "parametros": {"in_produto": "Lanterna"}},
+    ])
+    produtos = []
+
+    run_components(lambda nome: lambda params: produtos.append(params["in_produto"]))
+
+    assert produtos == ["Mochila", "Lanterna"]
+
+
+def test_passo_que_falha_fecha_o_passo_grava_o_erro_real_e_para(proton):
+    falso = proton([
+        {"nome": "FazerLogin", "ordem": 1},
+        {"nome": "FinalizarCompra", "ordem": 2},
+    ])
+
+    def login_recusado(params):
+        raise AssertionError("login recusado")
+
+    with pytest.raises(AssertionError, match="login recusado"):
+        run_components({"FazerLogin": login_recusado, "FinalizarCompra": lambda p: None})
+
+    assert falso.chamadas == ["start", "end"]
+    assert falso.status == RunStatus.FAILED.value
+    assert len(falso.erros) == 1
+    # O stack trace é o do passo, e não o da maquinaria de chamada.
+    assert "login_recusado" in falso.erros[0]
+    assert "AssertionError: login recusado" in falso.erros[0]
+
+
+def test_componente_que_nao_existe_no_projeto(proton):
+    falso = proton([{"nome": "Inexistente", "ordem": 1}])
+
+    with pytest.raises(ProtonRunError, match='"Inexistente" não existe'):
+        run_components({})
+
+    assert falso.chamadas == ["start", "end"]
+    assert falso.status == RunStatus.FAILED.value
+
+
+def test_passo_que_o_proton_nao_inicia_nao_vira_laco(proton):
+    falso = proton([{"nome": "FazerLogin", "ordem": 1}])
+    falso.inicio_falha = True
+
+    with pytest.raises(ProtonRunError, match="não iniciou"):
+        run_components({"FazerLogin": lambda p: None})
+
+    assert falso.chamadas == ["start"]
+
+
+def test_limite_de_passos(proton):
+    proton([{"nome": "Passo", "ordem": i} for i in range(1, 6)])
+
+    with pytest.raises(ProtonRunError, match="laço"):
+        run_components({"Passo": lambda p: None}, max_steps=3)
+
+
+def test_proximo_passo_de_outro_sistema_que_o_projeto_nao_tem_devolve_ao_runner(proton):
+    falso = proton([
+        {"nome": "FazerLogin", "ordem": 1, "sistema": "Web"},
+        {"nome": "ConferirPedido", "ordem": 2, "sistema": "SAP"},
+    ])
+
+    assert run_components({"FazerLogin": lambda p: None}) == 1
+    assert falso.status == "Running"
+    assert falso.chamadas == ["start", "end"]
+
+
+def test_proximo_passo_de_outro_sistema_que_o_projeto_tem_roda_no_mesmo_processo(proton):
+    falso = proton([
+        {"nome": "CriarPedido", "ordem": 1, "sistema": "SAP"},
+        {"nome": "ConferirPedido", "ordem": 2, "sistema": "Portal"},
+        {"nome": "ConsultarPedido", "ordem": 3, "sistema": "API"},
+    ])
+    rodados = []
+
+    def passo(nome):
+        return lambda params: rodados.append(nome)
+
+    assert run_components(passo) == 3
+    assert rodados == ["CriarPedido", "ConferirPedido", "ConsultarPedido"]
+    assert falso.status == RunStatus.PASSED.value
+
+
+def test_componente_que_falta_no_mesmo_sistema_falha_em_vez_de_devolver_ao_runner(proton):
+    falso = proton([
+        {"nome": "FazerLogin", "ordem": 1, "sistema": "Web"},
+        {"nome": "Esquecido", "ordem": 2, "sistema": "Web"},
+    ])
+
+    with pytest.raises(ProtonRunError, match='"Esquecido" não existe'):
+        run_components({"FazerLogin": lambda p: None})
+
+    assert falso.chamadas == ["start", "end", "start", "end"]
+    assert falso.status == RunStatus.FAILED.value
+
+
+def test_erro_ao_procurar_o_componente_marca_o_passo_e_falha(proton):
+    falso = proton([{"nome": "FazerLogin", "ordem": 1}])
+
+    def localizar(nome):
+        raise ImportError("falta a biblioteca do SAP")
+
+    with pytest.raises(ImportError, match="biblioteca do SAP"):
+        run_components(localizar)
+
+    assert falso.chamadas == ["start", "end"]
+    assert falso.status == RunStatus.FAILED.value
+
+
+def test_execucao_parada_nao_recebe_passed(proton):
+    falso = proton([{"nome": "FazerLogin", "ordem": 1}])
+
+    def parar(params):
+        falso.status = "Stopped"
+
+    run_components({"FazerLogin": parar})
+
+    assert falso.status == "Stopped"
+
+
+def test_execucao_sem_passo_pendente_nao_passa(proton):
+    falso = proton([])
+
+    with pytest.raises(ProtonRunError, match="não tem passo pendente"):
+        run_components({})
+
+    assert falso.status == RunStatus.FAILED.value
+
+
+def test_saida_fora_do_passo_avisa_sem_falhar(proton, caplog):
+    falso = proton([{"nome": "FinalizarCompra", "ordem": 1}])
+    falso.saidas_fora_do_passo = {"out_total"}
+
+    run_components({"FinalizarCompra": lambda p: {"out_total": "32.39"}})
+
+    assert falso.status == RunStatus.PASSED.value
+    assert any("out_total" in log and log.startswith("Aviso: ") for log in falso.logs)
+
+
+def test_saida_que_nao_e_dict_falha(proton):
+    proton([{"nome": "FinalizarCompra", "ordem": 1}])
+
+    with pytest.raises(ProtonRunError, match="esperado é um dict"):
+        run_components({"FinalizarCompra": lambda p: "32.39"})
+
+
+def test_evidencias_novas_do_passo_sobem_e_as_antigas_nao(proton, tmp_path):
+    pasta = tmp_path / "evidencias"
+    pasta.mkdir()
+    (pasta / "antiga.png").write_bytes(b"x")
+    falso = proton([{"nome": "FinalizarCompra", "ordem": 1}])
+
+    def finalizar(params):
+        (pasta / "pedido.png").write_bytes(b"x")
+        (pasta / "pedido.html").write_text("<html/>")
+
+    run_components({"FinalizarCompra": finalizar}, evidence_dir=str(pasta))
+
+    assert falso.imagens == [str(pasta / "pedido.png")]
+    assert falso.arquivos == [str(pasta / "pedido.html")]
+
+
+def test_evidencia_do_passo_que_falha_tambem_sobe(proton, tmp_path):
+    falso = proton([{"nome": "FinalizarCompra", "ordem": 1}])
+
+    def finalizar(params):
+        (tmp_path / "falha.png").write_bytes(b"x")
+        raise AssertionError("total errado")
+
+    with pytest.raises(AssertionError):
+        run_components({"FinalizarCompra": finalizar}, evidence_dir=str(tmp_path))
+
+    assert falso.imagens == [str(tmp_path / "falha.png")]
+
+
+def test_log_do_projeto_vai_para_a_execucao_so_durante_os_passos(proton):
+    falso = proton([{"nome": "FazerLogin", "ordem": 1}])
+    log = logging.getLogger("automacao")
+
+    run_components({"FazerLogin": lambda p: log.info("tela de produtos aberta")})
+    log.warning("depois da execução")
+
+    assert "tela de produtos aberta" in falso.logs
+    assert "Passo 1: FazerLogin" in falso.logs
+    assert not any("depois da execução" in item for item in falso.logs)
+    assert not any(isinstance(h, component_runner.ProtonLogHandler) for h in logging.getLogger().handlers)
+
+
+def test_fora_do_proton_avisa_em_vez_de_chamar_o_servidor(monkeypatch):
+    monkeypatch.delenv("idDatasetRun", raising=False)
+
+    with pytest.raises(ProtonRunError, match="só roda numa execução do Proton"):
+        run_components({})

{protoncloud_sdk-5.2.0 → protoncloud_sdk-5.3.0}/tests/test_proton_environment.py

@@ -12,7 +12,7 @@ import os
 import threading
 import warnings
 from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
-from urllib.parse import parse_qs, urlsplit
+from urllib.parse import parse_qs, unquote, urlsplit
 
 import pytest
 import requests
@@ -325,8 +325,11 @@ def test_valores_mascarados_no_log(proton, execucao, capsys, monkeypatch):
     # Prints da própria lib: rota que ecoa o valor e parâmetro de saída recusado.
     assert get_current_component_name() == ""
     assert set_proton_value("SENHA_LIDA", senha) == 400
-    # O parâmetro de saída é gravado de propósito: o valor enviado vai aberto.
-    assert proton.valores_gravados[0]["value"] == [SAP_SENHA]
+    # O parâmetro de saída é gravado de propósito: o valor enviado vai aberto. O backend
+    # decodifica o valor de novo depois de ler a query (troca "+" por espaço e aplica
+    # decodeURIComponent), e é aí que ele tem de chegar inteiro.
+    enviado = proton.valores_gravados[0]["value"][0]
+    assert unquote(enviado.replace("+", " "), errors="strict") == SAP_SENHA
 
     # Representação em texto do mapa e mensagens de erro.
     variaveis = get_environment_variables()

protoncloud_sdk-5.3.0/tests/test_proton_parameter.py

@@ -0,0 +1,41 @@
+"""
+Saída gravada pelo set_proton_value: o backend lê a query e decodifica o valor de novo
+(troca "+" por espaço e aplica decodeURIComponent). O valor tem de chegar inteiro, com
+"+", "%", acento e quebra de linha.
+"""
+
+from urllib.parse import parse_qs, unquote, urlparse
+
+import pytest
+
+from proton import proton_parameter
+
+
+class _Resposta:
+    status_code = 200
+    text = "{}"
+
+
+@pytest.fixture
+def backend(monkeypatch):
+    monkeypatch.setenv("idDatasetRun", "42")
+    monkeypatch.setenv("PROTON_HOST", "http://localhost:3333/api")
+    monkeypatch.setenv("PROTON_TOKEN", "proton_run_teste")
+    gravados = []
+
+    def put(url, params=None, headers=None):
+        # O que o requests põe na URL e o que o Adonis lê da query...
+        consulta = parse_qs(urlparse(proton_parameter.requests.Request("PUT", url, params=params).prepare().url).query)
+        valor = consulta["value"][0]
+        # ...e o que o set-value do backend faz em seguida.
+        gravados.append(unquote(valor.replace("+", " "), errors="strict"))
+        return _Resposta()
+
+    monkeypatch.setattr(proton_parameter.requests, "put", put)
+    return gravados
+
+
+@pytest.mark.parametrize("valor", ["São Paulo", "+55 11 91234-5678", "50% de desconto", "a&b=c", "linha 1\nlinha 2", "32.39"])
+def test_valor_chega_inteiro_no_backend(backend, valor):
+    assert proton_parameter.set_proton_value("out_valor", valor) == 200
+    assert backend == [valor]