protoncloud-sdk 5.3.1__tar.gz → 5.3.2__tar.gz

{protoncloud_sdk-5.3.1 → protoncloud_sdk-5.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: protoncloud-sdk
-Version: 5.3.1
+Version: 5.3.2
 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

{protoncloud_sdk-5.3.1 → protoncloud_sdk-5.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "protoncloud-sdk"
-version = "5.3.1"
+version = "5.3.2"
 description = "Proton Cloud SDK para Python: execução de automações, ambientes, logs, parâmetros e recursos."
 readme = "README.md"
 requires-python = ">=3.10"

{protoncloud_sdk-5.3.1 → protoncloud_sdk-5.3.2}/src/proton/proton_files_and_resources.py

@@ -87,54 +87,92 @@ def get_mobile_app(mobile_app_id):
         return {}
 
 def get_signed_url_file(entity, entity_id):
-    """Retorna a URL assinada para um arquivo."""
-    url = get_api_url("file-system")
-    header = get_auth_header()
+    """
+    Retorna o link assinado do arquivo de uma entidade do Proton.
 
-    params = {
-        "entity": entity,
-        "idEntity": entity_id
-    }
+    Usa a rota `GET /file-system/download` do Proton 5, com a entidade em minúsculas
+    (por exemplo, `mobile_app`).
 
-    response = requests.get(url, params=params, headers=header)
+    Returns:
+        dict: `{"id", "url", "fileName"}`, ou `{}` quando o arquivo não existe ou o
+        Proton recusa.
+    """
+    url = get_api_url("file-system/download")
+    params = {"entity": str(entity).strip().lower(), "idEntity": entity_id}
+
+    try:
+        response = requests.get(url, params=params, headers=get_auth_header(), timeout=60)
+    except requests.exceptions.RequestException as e:
+        set_log(f"Erro ao pedir o link do arquivo ({params['entity']} {entity_id}): {e}")
+        return {}
 
     if response.status_code == 200:
         return response.json()
-    else:
-        return {}
+
+    set_log(f"O Proton não entregou o arquivo ({params['entity']} {entity_id}). Status: {response.status_code}")
+    return {}
 
 def download_mobile_app(entity_id):
-    """Baixa uma aplicação mobile e retorna o caminho para o arquivo."""
-    json_file = get_signed_url_file("Mobile_App", entity_id)
+    """
+    Baixa o arquivo de um app cadastrado em Aplicativos Mobile do Proton.
 
-    try:
-        file_name = json_file.get("fileName", "")
-        app_file_path = ProtonClientParam._app_folder() + os.sep
+    O arquivo vai para `~/.proton-client/app/<id do app>/`, com o nome e a extensão
+    do cadastro (o Appium exige a extensão `.apk`).
 
-        os.makedirs(app_file_path, exist_ok=True)  # Cria a pasta se não existir
-        execute_download_file(json_file.get("url", ""), file_name, app_file_path)
-        return os.path.join(app_file_path, file_name)
+    Args:
+        entity_id: O id do app no Proton (o campo `app` da execução).
+
+    Returns:
+        str: O caminho do arquivo baixado, ou `""` quando não foi possível baixar.
+    """
+    json_file = get_signed_url_file("mobile_app", entity_id)
+    file_url = json_file.get("url", "")
+    file_name = os.path.basename(json_file.get("fileName", "") or "")
+
+    if not file_url or not file_name:
+        return ""
+
+    app_file_path = os.path.join(ProtonClientParam._app_folder(), str(entity_id))
+    os.makedirs(app_file_path, exist_ok=True)
 
-    except KeyError as e:
-        print(f"Erro ao obter informações de download: {e}")
+    if not execute_download_file(file_url, file_name, app_file_path):
         return ""
 
+    return os.path.join(app_file_path, file_name)
+
 def execute_download_file(file_url, file_name, save_dir):
-    """Realiza o download de um arquivo."""
+    """
+    Baixa um arquivo para a pasta indicada.
+
+    Grava num arquivo temporário e só então troca pelo definitivo: duas execuções em
+    paralelo com o mesmo app não leem um arquivo pela metade.
+
+    Returns:
+        bool: True quando o arquivo foi baixado.
+    """
+    save_file_path = os.path.join(save_dir, file_name)
+    temp_file_path = f"{save_file_path}.{os.getpid()}.part"
+
     try:
-        response = requests.get(file_url, stream=True) 
-        response.raise_for_status()  # Lança exceção em caso de código de erro
+        with requests.get(file_url, stream=True, timeout=60) as response:
+            response.raise_for_status()
 
-        save_file_path = os.path.join(save_dir, file_name)
-        with open(save_file_path, 'wb') as f:
-            for chunk in response.iter_content(chunk_size=BUFFER_SIZE):
-                f.write(chunk)
+            with open(temp_file_path, 'wb') as f:
+                for chunk in response.iter_content(chunk_size=BUFFER_SIZE):
+                    f.write(chunk)
 
+        os.replace(temp_file_path, save_file_path)
         set_log("Arquivo " + file_name + " baixado!")
+        return True
 
-    except requests.exceptions.RequestException as e:
+    except (requests.exceptions.RequestException, OSError) as e:
         set_log(f"Erro ao baixar arquivo: {e}")
 
+        if os.path.exists(temp_file_path):
+            os.remove(temp_file_path)
+
+        return False
+
 def get_component_file_id(component_id):
     """Retorna informações sobre o arquivo anexado no componente."""
     url = get_api_url("file")

protoncloud_sdk-5.3.2/tests/test_download_do_app.py

@@ -0,0 +1,92 @@
+"""
+Download do app cadastrado em Aplicativos Mobile: a SDK pede o link assinado pela rota
+do Proton 5 (`GET /file-system/download?entity=mobile_app&idEntity=<app>`) e baixa o
+arquivo para `~/.proton-client/app/<app>/`, com o nome e a extensão do cadastro.
+"""
+
+import os
+
+import pytest
+import requests
+
+from proton import proton_files_and_resources as arquivos
+from proton.proton_client_parama import ProtonClientParam
+
+
+class _Resposta:
+    def __init__(self, status_code=200, corpo=None, conteudo=b""):
+        self.status_code = status_code
+        self._corpo = corpo or {}
+        self._conteudo = conteudo
+
+    def json(self):
+        return self._corpo
+
+    def raise_for_status(self):
+        if self.status_code >= 400:
+            raise requests.exceptions.HTTPError(f"{self.status_code}")
+
+    def iter_content(self, chunk_size):
+        yield self._conteudo
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        return False
+
+
+@pytest.fixture
+def proton(monkeypatch, tmp_path):
+    monkeypatch.setenv("PROTON_HOST", "http://localhost:3333/api")
+    monkeypatch.setenv("PROTON_TOKEN", "proton_run_teste")
+    monkeypatch.setattr(ProtonClientParam, "_app_folder", classmethod(lambda cls: str(tmp_path / "app")))
+
+    estado = {"link": _Resposta(200, {"id": 7, "url": "https://s3/assinado", "fileName": "mda-2.3.0.apk"}),
+              "arquivo": _Resposta(200, conteudo=b"APK"), "pedidos": []}
+
+    def get(url, params=None, headers=None, stream=False, timeout=None):
+        estado["pedidos"].append((url, params, headers))
+        return estado["arquivo"] if stream else estado["link"]
+
+    monkeypatch.setattr(arquivos.requests, "get", get)
+    return estado
+
+
+def test_pede_o_link_pela_rota_do_proton_5(proton):
+    arquivos.download_mobile_app("15")
+
+    url, params, headers = proton["pedidos"][0]
+    assert url == "http://localhost:3333/api/file-system/download"
+    assert params == {"entity": "mobile_app", "idEntity": "15"}
+    assert headers == {"Authorization": "Bearer proton_run_teste"}
+
+
+def test_baixa_o_app_com_a_extensao_na_pasta_do_app(proton, tmp_path):
+    caminho = arquivos.download_mobile_app("15")
+
+    assert caminho == os.path.join(str(tmp_path / "app"), "15", "mda-2.3.0.apk")
+    with open(caminho, "rb") as f:
+        assert f.read() == b"APK"
+    assert os.listdir(tmp_path / "app" / "15") == ["mda-2.3.0.apk"]
+
+
+def test_proton_recusa_o_link_devolve_vazio(proton):
+    proton["link"] = _Resposta(403, {"message": "executionTokenOtherRun"})
+
+    assert arquivos.download_mobile_app("15") == ""
+
+
+def test_falha_no_download_devolve_vazio_e_nao_deixa_arquivo(proton, tmp_path):
+    proton["arquivo"] = _Resposta(404)
+
+    assert arquivos.download_mobile_app("15") == ""
+    assert os.listdir(tmp_path / "app" / "15") == []
+
+
+def test_nome_do_arquivo_nao_sai_da_pasta_do_app(proton, tmp_path):
+    proton["link"] = _Resposta(200, {"id": 7, "url": "https://s3/assinado", "fileName": "../../fora.apk"})
+
+    caminho = arquivos.download_mobile_app("15")
+
+    assert caminho == os.path.join(str(tmp_path / "app"), "15", "fora.apk")