- Notas relacionadas
- Primeros pasos
- Instalación y configuración
- Proyectos de automatización
- Acerca de la publicación de proyectos de automatización
- Diseñar automatizaciones
- Gestionar paquetes de actividades
- Configuración de los Ajustes del Proyecto de Actividades
- Firma de paquetes
- Control
- Importar entidades
- Experiencia de diseño moderna
- Vincular un proyecto a una idea en Automation Hub
- Usar Data Manager
- Dependencias
- Tipos de flujos de trabajo
- Flujo de control
- Comparación de archivos
- Mejores prácticas de automatización
- Integración del control de código fuente
- Depuración
- Registro
- La herramienta de diagnóstico
- Analizador de flujo de trabajo
- Acerca del analizador de flujo de trabajo
- ST-NMG-001: convención sobre nombres de variables
- ST-NMG-002: convención de nombres de argumentos
- ST-NMG-004: duplicación de nombres de visualización
- ST-NMG-005: anulación de variables
- ST-NMG-006: argumentos de anulación de variables
- ST-NMG-008: longitud variable excedida
- ST-NMG-009: variables de datos prefijados
- ST-NMG-011: argumentos de prefijo Datatable
- ST-NMG-012: valores predeterminados de los argumentos
- ST-NMG-016: longitud del argumento excedida
- ST-NMG-017: el nombre de la clase coincide con el espacio de nombres predeterminado
- ST-DBP-002: recuento de Argumentos elevado
- ST-DBP-003: bloque de Catch vacío
- ST-DBP-007: múltiples capas de diagramas de flujo
- ST-DPB-010: varias instancias de [Flujo de trabajo] o [Caso de prueba]
- ST-DBP-020: propiedades de salida no definidas
- ST-DBP-021: tiempo de espera codificado
- ST-DBP-023: flujo de trabajo vacío
- ST-DBP-024: comprobación de actividad de persistencia
- ST-DBP-025: requisito previo para la serialización de variables
- ST-DBP-026: retraso en el uso de la actividad
- ST-DBP-027: mejor práctica de persistencia
- ST-DBP-028: requisito de serialización de argumentos
- ST-USG-005: argumentos de actividad codificados
- ST-USG-009: variables no utilizadas
- ST-USG-010: dependencias sin utilizar
- ST-USG-014: restricciones de los paquetes
- ST-USG-020: mensajes de registro mínimos
- ST-USG-024: guardado sin usar para más adelante
- ST-USG-025: uso incorrecto de los valores guardados
- ST-USG-026: restricciones de actividad
- ST-USG-027: paquetes necesarios
- ST-USG-028: Restringir la invocación de plantillas de archivo
- ST-USG-032 - Etiquetas obligatorias
- ST-USG-034 - URL Automation Hub
- Variables
- Argumentos
- Espacios de nombres importados
- Automatizaciones codificadas
- Introducción
- Registrar servicios personalizados
- Contextos Antes y Después
- Generando código
- Generar casos de prueba codificados a partir de casos de prueba manuales
- Automatización atendida basada en desencadenadores
- Grabación
- Elementos de la IU
- Selectores
- Repo. de objetos
- Extracción de datos
- Automatización de imágenes y texto
- Acerca de la automatización de imágenes y texto
- Actividades con el ratón y el teclado
- Ejemplo de uso de la automatización de ratón y teclado
- Actividades de texto
- Ejemplo de uso de la automatización de texto
- Actividades de OCR
- Actividades de imagen
- Ejemplo de uso de la automatización de OCR y la automatización de imágenes
- Automatizar las tecnologías de Citrix
- Automatización RDP
- Automatización de VMware Horizon
- Automatización de Salesforce
- Automatización SAP
- macOS UI Automation
- La herramienta ScreenScrapeJavaSupport
- El protocolo WebDriver
- Extensiones
- Acerca de las extensiones
- Herramienta SetupExtensions
- UiPathRemoteRuntime.exe no se está ejecutando en la sesión remota
- UiPath Remote Runtime impide que la sesión de Citrix pueda cerrarse
- UiPath Remote Runtime provoca una fuga de memoria
- Las versiones de UiPath Remote Runtime y UiPath Remote Runtime no coinciden
- La extensión de UiPath necesaria no está instalada en la máquina remota
- Configuración de la resolución de la pantalla
- Directivas de grupo de Chrome
- No se puede comunicar con el navegador
- La extensión de Chrome se elimina automáticamente
- Es posible que la extensión se haya dañado
- Comprueba si la extensión para Chrome está instalada y habilitada
- Check if ChromeNativeMessaging.exe is running
- Check if ComSpec variable is defined correctly
- Habilitar el acceso a las URL de archivos y el modo de incógnito
- Multiple browser profiles
- Group Policy conflict
- Known issues specific to MV3 extensions
- Lista de extensiones para Chrome
- Extensión de Chrome en Mac
- Directivas de grupo de Edge
- No se puede comunicar con el navegador
- La extensión de Edge se elimina automáticamente
- Es posible que la extensión se haya dañado
- Check if the Extension for Microsoft Edge is installed and enabled
- Check if ChromeNativeMessaging.exe is running
- Check if ComSpec variable is defined correctly
- Enable access to file URLs and InPrivate mode
- Multiple browser profiles
- Group Policy conflict
- Known issues specific to MV3 extensions
- Lista de extensiones para Edge
- Extensión para Safari
- Extensión para VMware Horizon
- Extensión para Amazon WorkSpaces
- Complemento SAP Solution Manager
- Add-in de Excel
- Conjunto de pruebas - Estudio
- Solución de problemas
- Acerca de la resolución de problemas
- Compatibilidad y limitaciones de Microsoft App-V
- Solución de problemas de Internet Explorer x64
- Problemas de Microsoft Office
- Identificación de elementos de la interfaz de usuario en PDF con opciones de accesibilidad
- Reparar Soporte Active Accessibility
- Validation of large Windows-legacy projects takes longer than expected
Contextos Antes y Después
BeforeRunContext
(Configuración): la ejecución Antes se utiliza para realizar acciones antes de la ejecución principal del caso de prueba. A menudo se utiliza para configurar el estado inicial del entorno de prueba y preparar recursos. Algunos casos de uso comunes para el contexto Antes incluyen:- Inicializar variables o datos necesarios para la prueba.
- Configurar conexiones a sistemas externos o bases de datos.
- Registrar el inicio de la ejecución de la prueba.
- Abrir aplicaciones o páginas web con las que interactúa la prueba.
- Configurar excepciones específicas antes de ejecutar el caso de prueba.
AfterRunContext
(Desmontaje): la ejecución Después se utiliza para realizar acciones después de que se complete la ejecución principal del caso de prueba. Normalmente se utiliza para limpiar recursos, finalizar operaciones y registrar los resultados de la prueba. Los casos de uso comunes para el contexto Después incluyen:- Cerrar aplicaciones o páginas web utilizadas durante la prueba.
- Liberar recursos, como las conexiones de la base de datos o los recursos de red.
- Captura e imprime las excepciones registradas en el contexto Antes y la ejecución principal.
IBeforeAfterRun
adyacente a la clase principal y luego implementando tu propia lógica personalizada para estas acciones.
BeforeRunContext
, puedes encontrar el siguiente fragmento de código:// Context of the run before the execution.
public class BeforeRunContext
{
// The relative path of the workflow.
public string RelativeFilePath { get; set; }
}
// Context of the run before the execution.
public class BeforeRunContext
{
// The relative path of the workflow.
public string RelativeFilePath { get; set; }
}
Este contexto representa el estado antes de la ejecución de la automatización. Contiene información sobre la ruta relativa del flujo de trabajo que se ejecuta. Puedes configurar excepciones aquí, según tu caso de uso.
AfterRunContext
, puedes encontrar el siguiente fragmento de código:// Context of the run after the execution.
public class AfterRunContext
{
// The relative path of the workflow.
public string RelativeFilePath { get; set; }
// The exception caught in execution if any.
public Exception Exception { get; set; }
}
// Context of the run after the execution.
public class AfterRunContext
{
// The relative path of the workflow.
public string RelativeFilePath { get; set; }
// The exception caught in execution if any.
public Exception Exception { get; set; }
}
Este contexto representa el estado después de la ejecución de la automatización. Incluye detalles sobre la ruta relativa del flujo de trabajo ejecutado y cualquier excepción capturada antes y durante la ejecución.
Before
y las ejecuciones principales operan simultáneamente, capturando las excepciones que aparecen durante la ejecución. Cualquier excepción lanzada durante estas fases se captura y almacena en AfterRunContext
, dejándolo como nulo si no se producen excepciones.
Before
y las ejecuciones principales, se ejecuta el método After
. Si se lanza una excepción durante la ejecución After
, la ejecución finaliza y se lanza la excepción correspondiente.
Before
y After
, , se agrupan en un AggregateException
.
Puedes implementar la interfaz de las ejecuciones Antes y Después directamente dentro de tu caso de prueba codificado.
- Dentro de la clase pública donde reside tu caso de prueba codificado, añade la interfaz
IBeforeAfterRun
. Esto se resaltará en rojo, lo que indica posibles correcciones.public class MyTest : CodedWorkflow, IBeforeAfterRun
public class MyTest : CodedWorkflow, IBeforeAfterRun - Elige Mostrar posibles correcciones o presiona
Ctrl + .
y selecciona Implementar interfaz.Esto generará una interfaz predeterminada de la siguiente manera:public void After(AfterRunContext context) { throw new NotImplementedException(); } public void Before(BeforeRunContext context) { throw new NotImplementedException(); }
public void After(AfterRunContext context) { throw new NotImplementedException(); } public void Before(BeforeRunContext context) { throw new NotImplementedException(); } - Modifica la implementación según tus necesidades.
En el ejemplo de código proporcionado, el contexto registra un mensaje antes de la ejecución y comprueba si hay excepciones después.
public void After(AfterRunContext context) { if (context.Exception != null) { Log(context.Exception.Message); } } public void Before(BeforeRunContext context) { Log("this is before"); }
public void After(AfterRunContext context) { if (context.Exception != null) { Log(context.Exception.Message); } } public void Before(BeforeRunContext context) { Log("this is before"); }
.cs
dentro de tu proyecto, utilizando una clase parcial personalizada.
- Crea un archivo de código fuente. Aquí es donde implementas la interfaz de las ejecuciones antes y después. Para este ejemplo, nombra el archivo
TestCaseBase
.- Añade la interfaz
IBeforeAfterRun
junto a la clase pública. Esto se resaltará en rojo, lo que indica posibles correcciones.Nota: la clase parcial personalizada (TestCaseBase
en este ejemplo) debe heredar la claseCodedWorkflow
. Esto permite que otros archivoscs
, que heredan la clase parcial personalizada, se ejecuten como se espera.public class TestCaseBase : CodedWorkflow, IBeforeAfterRun
public class TestCaseBase : CodedWorkflow, IBeforeAfterRun - Elige Mostrar posibles correcciones o presiona
Ctrl + .
y selecciona Implementar interfaz.Esto generará una interfaz predeterminada de la siguiente manera:public void After(AfterRunContext context) { throw new NotImplementedException(); } public void Before(BeforeRunContext context) { throw new NotImplementedException(); }
public void After(AfterRunContext context) { throw new NotImplementedException(); } public void Before(BeforeRunContext context) { throw new NotImplementedException(); } - Modifica la implementación según tus necesidades.
En el ejemplo proporcionado, el contexto registra un mensaje antes de la ejecución y comprueba si hay excepciones después.
public void After(AfterRunContext context) { if (context.Exception != null) { throw context.Exception; } else { Log("Test " + context.RelativeFilePath + " finished with no exception."); } } public void Before(BeforeRunContext context) { Log("Execution started for " + context.RelativeFilePath); }
public void After(AfterRunContext context) { if (context.Exception != null) { throw context.Exception; } else { Log("Test " + context.RelativeFilePath + " finished with no exception."); } } public void Before(BeforeRunContext context) { Log("Execution started for " + context.RelativeFilePath); }
Ahora puedes utilizar esta clase parcial personalizada para utilizar la misma interfaz de las ejecuciones antes y después solo para los archivos.cs
que la heredan. - Añade la interfaz
- Crea una automatización codificada. Para este ejemplo, crea un caso de prueba codificado llamado
TestCase
. Para utilizar la misma interfaz de las ejecuciones antes y después de la clase parcial personalizada, asegúrate de que el caso de prueba codificado hereda de esta clase parcial.public class TestCase : TestCaseBase { [TestCase] public void Execute() { Log("Executing the test..."); }
public class TestCase : TestCaseBase { [TestCase] public void Execute() { Log("Executing the test..."); }
Execution started for file: TestCase.cs
[Info] IBeforeAfterRunExamples execution started
[Info] Execution started for TestCase.cs
[Info] Executing the test...
[Info] Test TestCase.cs finished with no exception.
[Info] IBeforeAfterRunExamples execution ended in: 00:00:00
Execution started for file: TestCase.cs
[Info] IBeforeAfterRunExamples execution started
[Info] Execution started for TestCase.cs
[Info] Executing the test...
[Info] Test TestCase.cs finished with no exception.
[Info] IBeforeAfterRunExamples execution ended in: 00:00:00
CodedWorkflow
parcial, que cualquier otro caso de prueba codificado o flujo de trabajo codificado dentro de tu proyecto puede heredar. Esta implementación se aplica a todos los casos de prueba codificados y flujos de trabajo codificados dentro de tu proyecto.
- Crea un archivo de código fuente y nómbralo de forma diferente que
CodedWorkflow.cs
, de lo contrario la clase parcial tendrá un conflicto con la claseCodedWorkflow
de solo lectura existente. - Construye una clase parcial que implemente la interfaz personalizada para los contextos Antes y Después.
- Cambia el nombre de la clase a
CodedWorkflow
.De lo contrario, no podrás utilizar los servicios disponibles. - Asegúrate de que la clase dentro de tu archivo de origen codificado hereda la clase
CodedWorkflowBase
. - Añade el espacio de nombres
UiPath.CodedWorkflows
al inicio de tu archivo de código fuente.using System; using System.Collections.Generic; using UiPath.CodedWorkflows;
using System; using System.Collections.Generic; using UiPath.CodedWorkflows; - Dentro de la clase de tu archivo de código fuente, incluye
IBeforeAfterRun
.namespace TestAutomationProject1 { public partial class CodedWorkflow : CodedWorkflowBase, IBeforeAfterRun
namespace TestAutomationProject1 { public partial class CodedWorkflow : CodedWorkflowBase, IBeforeAfterRun - Pasa el puntero del ratón sobre
IBeforeAfterRun
y selecciona Mostrar posibles correcciones o selecciónalo y presionaCtrl + .
. - Selecciona Implementar interfaz.
Esto crea la siguiente implementación predeterminada:
public void After(AfterRunContext context) { throw new NotImplementedException(); } public void Before(BeforeRunContext context) { throw new NotImplementedException(); }
public void After(AfterRunContext context) { throw new NotImplementedException(); } public void Before(BeforeRunContext context) { throw new NotImplementedException(); } - Opcionalmente, puedes personalizar aún más la interfaz, según tu caso de uso. En la siguiente muestra de código, el contexto imprime un mensaje antes de la ejecución y después de la ejecución comprueba si se lanzó alguna excepción y lo imprime de nuevo.
public void After(AfterRunContext context) { if (context.Exception != null) { Log(context.Exception.Message); } } public void Before(BeforeRunContext context) { Log("this is before"); }
public void After(AfterRunContext context) { if (context.Exception != null) { Log(context.Exception.Message); } } public void Before(BeforeRunContext context) { Log("this is before"); }