TAST DokuWiki

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Modelado 2.0 ======

Esta opción de la herramienta TAST permite al usuario administrar diagramas UML. También podrá gestionar los datos y gestionar los repositorios de los casos de prueba que se diseñen.\\ \\ {{:es:modelado.png?link&450|}}\\ \\


===== Diagrama UML 2.0 =====

Esta opción de la herramienta TAST permite al usuario **gestionar todos los tratamientos asociados con los diagramas UML.**\\ \\   
===== Como crear un diagrama UML =====

Los diagramas UML son completamente necesarios para la creación de los casos de prueba. Esto se debe a que cada mensaje del diagrama representa una acción que se llevará a cabo en la prueba (click o escriba, por ejemplo). En los párrafos siguientes, se explica cómo se puede crear un diagrama UML.

Cuando haya iniciado sesión en la herramienta, el usuario puede ver un menú en el lado izquierdo (consulte [[First steps in TAST]] para obtener más información). En este menú, el usuario hará click en el botón "Modelo".\\ \\ 
{{ :es:modelo_2.png?link&200 |}}\\ \\ Una vez en la página Modelado, el usuario puede proceder de tres maneras:

  * **Seleccionar** y **modificar** uno de los casos de prueba ya creados.
  * **Crear** un nuevo caso de prueba.
  * **Importar** un caso de prueba creado con cualquier otra herramienta de diseño UML.\\ \\ 


{{ :es:modelo_1.png?link&500 |}}\\ \\ 

  * Si el usuario elige **modificar** un diagrama UML existente (lado izquierdo de la captura de pantalla superior), habrá 4 colores diferentes para los casos de prueba: verde para los casos donde el mapeo se ha completado y ejecutado correctamente, amarillo para los casos en los que el mapeo se ha completado pero no ejecutado, rojo en los casos donde el mapeo se ha completado y ejecutado con error y gris para los casos que están vacíos.\\ 
  
  * Si elige **crear** un nuevo diagrama UML, es necesario hacer click en el icono (+) "Nuevo diagrama" de la pestaña situada en el lado superior derecho. Después de esto, se abrirá una nueva ventana como se muestra a continuación:\\ \\ {{ :es:crear_nuevo_diagrama_uml.png?direct&250 |}}\\ Donde tendrá que ir cumplimentando los siguientes campos:\\ \\ 
      * Dominio: este es el dominio al que pertenecerá el caso de prueba.
      * Proyecto: seleccione el proyecto al que se vinculará el caso de prueba.
      * Carpeta: carpeta del sistema donde se almacenará el caso de prueba. 
      * Nombre del diagrama.
      * Descripción del diagrama.
      * Usar plantilla de diagrama.
      * Copiar el mapeo de validación.
      * Visibilidad como plantilla:\\ 
        * Público.
        * Dominio.
        * Proyecto.
        * Privado.
        * Ninguno.\\ \\ **IMPORTANTE**: Los proyectos y dominios deben crearse antes de la realización del caso de prueba y, además, el usuario debe asignarse al dominio y al proyecto. De lo contrario, el usuario no podrá ver ni el dominio del proyecto, ni los casos de prueba que ya se hayan creado. Para obtener más información sobre la creación del dominio y el usuario, consulte la página [[es:customize._domains_and_projects]].\\ 

   * Si el usuario elige **importar** un caso de prueba ya creado, pulsará el botón de "Importar" que está cerca del botón de "Nuevo diagrama".\\ \\ {{ :es:imagen_2_importar_exportar_diagrama.png?100 |}}\\ \\ y se abrirá una nueva ventana con información sobre donde guardar este diagrama (consulte la página [[es:diagram_import_export]] ).\\ \\ 

===== Editar un diagrama =====

Esta opción de la herramienta TAST permite ** crear/modificar un diagrama.**\\ \\ 
A continuación vemos **la pantalla o lienzo en blanco** para editar un diagrama. Es el Canvas 2.0.  En la parte superior derecha (marcada en rojo), esta la barra de herramientas del Canvas, que ofrece diferentes opciones para el **diseño** del diagrama. Vamos a verlas a continuación:\\ \\ {{ :es:barra_de_herramientas.png?link&700 |}}\\  

  * **Seleccionar** los elementos a incluir en el diagrama a través del icono '+':
    
{{ :es:herramientas_de_dibujo.png?link&300 |}}

  * **Borrar elementos**: permite borrar el o los objetos del diagrama que se hayan seleccionado utilizando el icono de la 'papelera'.
  * **Acciones de diagrama**: agrupa una serie de acciones que se pueden realizar a nivel de diagrama:

{{ :es:acciones_de_diagrama.png?link&300 |}}

  * **Asistentes**: muestra una lista con los asistentes disponibles:

{{ :es:asistentes.png?link&300 |}}

  * **Visualizar mapa del diagrama**: pulsando este botón, se muestra una miniatura del diagrama actual (a una escala de 4:1) que aparecerá en un recuadro en la parte superior derecha del Canvas. 
  * **Lupa**: permite realizar búsquedas de texto libre en todos los elementos del diagrama, y también permite acotar las búsquedas sobre aquellos elementos que nos interesen en un momento dado. 
  * **Recargar repositorios**: nos permite recargar archivos YML o TXT, los cuales contienen una serie de claves que podremos usar en los diagramas. 
  * **Descargar imagen del diagrama**: haciendo click en el icono de 'imagen', se genera una imagen “al vuelo” tal y como es el diagrama actual, es decir se crea un preview del diagrama y se descarga a un fichero .png
  * **Validar mapeo**: valida los mapeos incluidos en el diagrama usando el icono 'validar mapeo'.
  * **Ejecutar validación**: ejecuta la validación del diagrama con el icono de 'reproducción'. 
  * **Mostrar ayuda del Canvas**: aparece un modal con 3 pestañas (Atajos de teclado, Variables globales, Guía de Colores) donde se muestra la ayuda básica del Canvas.\\ 
    * Pestaña "Atajos de teclado": muestra todos los atajos de teclado que equivalen a acciones realizadas bien a través de opciones de menú o de botones:\\ \\ {{ :es:atajos.png?link&300 |}} \\ \\ 
    * Pestaña “Variables globales”: muestra las variables globales estándar disponibles en cualquier diagrama:\\ \\    {{ :es:variables_globales.png?direct&300 |}}\\ \\ 
    * Pestaña “Guía de Colores”: se refiere a los distintos colores que podemos encontrar ahora en los objetos del diagrama:\\ \\ {{ :es:guia_de_colores.png?direct&200 |}}\\ \\ 


==== Comprobación en la pestaña de propiedades del objeto ==== 
El objeto u objetos (Adaptadores), es el elemento principal a la hora de crear un diagrama. Dos pestañas ayudan a definir el nombre del objeto, sus propiedades y los parámetros de inicialización o configuración, para poder interactuar con páginas web, archivos, API, scripts, remotos, BBDD.\\ \\ 
{{ :es:propiedades_del_objeto.png?direct&600 |}}\\ \\ 
==== Comprobación en la pestaña de propiedades del mensaje ====

En un mensaje, tras hacer doble click, es posible indicar el tipo de acción que se hará cuando el paso deba ejecutarse, según los siguientes campos: 

{{ :es:punto_de_ruptura.png?500 |}}\\ 
  - **Mensaje bloqueante:** Si el mensaje falla, la ejecución del paso fallará y el caso de prueba no continua; termina en este punto.
  - **Paso Opcional:** Si está marcado, el resultado de este paso no impactará en el resultado final. 
  - **Comentario:** Si está marcado, el mensaje no se ejecutará.
  - **Punto de ruptura:** La comprobación del punto de ruptura se utiliza para detener la ejecución de la prueba en este paso. Es útil durante la creación del diagrama.\\ \\ 

==== Guardia ====

Una guardia es una condición lógica que se puede incluir en cualquier mensaje dentro de los diagramas UML. Cuando esta condición se cumple el mensaje se ejecuta, cuando esta condición no se cumple, el mensaje NO se ejecuta.
Una guardia es muy útil cuando una acción debe ejecutarse o no, dependiendo de un condicionante.\\ \\ 
{{ :es:modeling_2.0.guardia.png?direct&500 |}}\\ \\ 
Las condiciones dentro de una guardia pueden ser del tipo:

  * **Sencillas**: por medio de operadores lógicos, < (menos que), > (mayor que), == (igual a), != (distinto de), < = (menos o igual que), >= (mayor o igual que).
  * **Complejas**: concatenando condiciones sencillas por medio de operadores lógicos como: AND (y), OR (or), && (y exclusivo), || (o exclusivo)

A continuación, algunos ejemplos sobre condiciones simples y complejas en una guardia:

  * **#numCol < 25**\\ En este caso, el mensaje se ejecutará cuando, la variable tipointeger numCol sea inferior de 25.
  * **#myFavoriteApp == “TAST”**\\ En este el mensaje se ejecutará cuando la variable tipo String myFavoriteApp sea igual al String "TAST". Debe ser considerado que los String  deben compararse con el símbolo de comillas "".
  * ** #fahrzeugtypTestData  =="Gebrauchtwagen"||#fahrzeugtypTestData=="Vorf-hrwagen" ||#fahrzeugtypTestData"Tageszulassung"**\\ En este caso, el mensaje se ejecutará cuando la variable tipo String fahrzeugtypTestData, contenga uno de los siguientes valores: Gebrauchtwagen, Vorf-hrwagen, Tageszulassung.
  * ** #str1 ==“TAST” AND #str2==“TaaS” AND #str3==“SIPSA”**\\ En este caso el mensaje se ejecutará cuando la variable tipo String str1 sea igual a TAST y cuando la variable str2 sea igual a TaaS y cuando la variable str3 sea igual a SIPSA.\\ \\ 

====Texto de varias líneas====

En la asignación de un mensaje, es posible incluir un valor con salto de línea. Para ello, hay una casilla de verificación 'Texto multilínea':\\  

{{ :es:multilinea1.png?link&500 |}} 

Si la casilla de verificación está seleccionada, aparecerá un editor para incluir el texto:\\ \\ {{ :es:multilinea2.png?link&500 |}}\\ {{ :es:multilinea3.png?link&300 |}}\\ 

==== Mensaje de respuesta ====

Este mensaje tiene que estar vinculado a otro mensaje entre dos objetos y se traza en la dirección opuesta al vínculo. Los dos mensajes forman un conjunto y no se tratan por separado.\\ \\ 

{{ :Reply message_1.png?link&400 |}}\\ 

  * La única función permitida en el mensaje de respuesta es la //aserción//, que tiene como parámetros de entrada //stepResult// (resultado del mensaje anterior) y puede tener más parámetros. El parámetro de salida también es //stepResult//.

  * Este mensaje nos permite variar el resultado del paso anterior comprobando algunas condiciones. Este proceso se realiza utilizando un javascript.\\ \\ {{ :Reply message_4_def.png?link&250 |}}GESTION DE DATOS: Permite modificar el javascript de cada uno de los diagramas.\\ \\ {{ :Reply message DM.png?link&500 |}}\\ 


==== Gates ====

Esta opción de la herramienta TAST permite al usuario pasar información entre diagramas de secuencia. Las Gates pueden ser una forma sencilla de modelar el paso de información entre un diagrama de secuencia y su contexto. Una Gate es simplemente un mensaje que se ilustra con un extremo conectado al borde del marco del diagrama de secuencia y el otro extremo conectado a una lifeline y representa otro diagrama.

Puntos importantes a tener en cuenta sobre las Gates:

  * La **posición del adaptador dentro de la Gate es muy importante para el comportamiento correcto** porque la Gate también está relacionada con el Adaptador que planea instanciar. Por lo tanto, debe poner la Gate no sólo en el paso de número, sino también en la lifeline donde puede continuar la ejecución de la prueba. Por ejemplo, si quiere utilizar una Gate a un Adaptador GUI HTML, debe colocar la gate en la misma línea del adaptador GUI HTML en el diagrama Padre.
  * El comportamiento **Aislado** siempre instanciará todos los adaptadores.
  * El comportamiento **No aislado**: mapea los mensajes del primer adaptador de la Gate que tiene el mismo tipo que el adaptador del padre donde se dibuja; el resto de los adaptadores serán instanciados.
  * El concepto de **Aislado / No Aislado** se configura internamente en TAST. Actualmente, ese concepto **solo se aplica a estos adaptadores: Adaptador GUI** y ** Adaptador Web Services**.
  * Para las Gates del Usuario: todas las Gates de las lifelines pertenecientes a los objetos de Usuario son mapeadas se asignan al objeto de Usuario del diagrama Padre.

Cómo crear un Gate:\\  

En la barra de herramientas, seleccione la Gate y dibuje en la misma línea. Haga doble click y abra las propiedades de la Gate, donde elija el dominio, el proyecto y el diagrama que desea copiar.\\ \\ 
{{ :es:gate01.png?link&500 |}}\\ \\ El diagrama seleccionado se puede visualizar haciendo click en el icono de la imagen.\\ \\ {{ :es:gate02.png?link&500 |}}\\ \\ Al hacer click en el mapeo de la Gate, se mostrará una pantalla cómo la siguiente:\\ \\ [[Esta pantalla no he podido cambiarla, abro mapeo de la gate de mi diagrama y no me aparece igual a la antigua]]\\ \\ {{ :Mapeo del gate .png?link&500 |}}\\ \\ GESTION DE DATOS: Permite asignar datos de casos de prueba a cada Gate incluida en los diagramas.\\ \\ {{ :es:gate04.png?link&500 |}}\\ \\ EJECUCIÓN DE PRUEBA ESTABLECIDA CON GATES: Se crea y ejecuta un conjunto de pruebas que contiene Gates.\\ \\ {{ :Ejecución de TS con Gate.png?link&500 |}}\\ \\ 

====Fragmentos combinados ====

Esta opción de la herramienta TAST permite al usuario manejar //bifurcaciones// y //loops (bucles)//.

TAST permite los siguientes tipos de fragmentos combinados:\\ \\ 
[[Falta cambiar 1 pantalla de propiedades del fragmento a español (FOR EACH)]]\\ \\ 
  * Para manejar bifurcaciones: 
        * **CF ALT**: si la condición indicada en la Guard del Fragmento Combinado es verdadera, se ejecutarán los pasos de la primera parte del ALT; de lo contrario, los pasos ejecutados serán los de la parte 'else':\\ \\ {{ :es:fcalt2.png?direct&600 |}}\\ {{ :es:fcalt1.png?direct&500 |}}\\ \\  
  * Para manejar bucles: 
         * **CF Loop do while**: mientras que la condición indicada en las propiedades del fragmento combinado es verdadera, los pasos del fragmento combinado serán ejecutados. La condición se comprueba después de ejecutar los pasos, por lo que el //loop do while// garantiza la ejecución del loop al menos una vez:\\ \\ {{ :es:fcbucledowhile2.png?direct&600 |}}\\ {{ :es:fcbucledowhile1.png?direct&500 |}}\\ \\ 

        * **CF Loop while**: este bucle es similar a //loop do while//. La diferencia es cuando se evalúa la condición de salida del ciclo. En el // loop while// esta evaluación se realiza antes de entrar en el ciclo, lo que significa que el bucle puede no ser ejecutado:\\ \\ {{ :es:fcwhile2.png?direct&600 |}}\\ {{ :es:fcwhile1.png?direct&500 |}}\\ 

       * **CF Loop for**: Todos los pasos incluidos en este bucle se ejecutarán varias veces, de acuerdo con los parámetros indicados en la pestaña de propiedades del fragmento:\\ //Guard:// este campo indica la condición que debe cumplir la variable especificada para ejecutar los pasos del loop for. Esta variable aparecerá en la sección 'Variable para iteración'.\\ //Case start:// contiene el valor inicial que la variable tomará para la iteración dentro del loop.\\ //Tipo de incremento:// tipo de incremento de la variable. Puede ser incremental (+) o decremental (-).\\ \\ {{ :es:fcbuclefor2.png?nolink&600 |}}\\ {{ :es:fcbuclefor1.png?direct&500 |}}\\ 

       * **CF Loop for each**: Permite iterar uno por uno (desde 1 ... n) la fila o columna seleccionada de una tabla introducida como variable. Permite manejar una a una la información seleccionada de forma vertical u horizontal.\\ \\ {{ :CF_for each_eng_1.png?link&500 |}}\\ \\ {{ :CF_for each_eng_2.png?link&300 |}}\\ \\ Para obtener datos del objeto, hay que utilizar el nombre de la tabla, seguido de la palabra "Row", usando el método getCellValue(n).\\ \\ {{ :es:foreachfilas.png?500 |}}\\ \\ En el caso de la columna, hay que poner el nombre de la tabla, seguido de la palabra "Column", usando el método  getCellValue(n).\\ \\ {{ :es:foreachcolumnas.png?500 |}}\\ \\ Donde (n) es la posición de la celda en la fila o la posición de la celda en la columna.\\ \\ 

==== SubTestCases ====

Los Subtestcases son casos de prueba que pueden ser pintados en un diagrama. La razón para implementar los subtestcases consiste en tener una opción visual en modelado de casos de prueba y verlos dibujados aparte de sólo tenerlos en gestión de datos. También para recibir un log o resultado de un caso aislado aparte del resultado total.
 
=== Cómo usarlo en un diagrama ===

Para usar un subtestcase en un diagrama se tiene que ir a la barra de herramientas, hacer cick en el icono "+" y a continuación seleccionar subtestcase. También podemos usar "ALT + S" como acceso directo para dibujarlo. Para colocarlo en el canvas se tendrá que hacer click donde se quiera colocar.

{{ :es:herramientas_de_dibujo.png?direct&400 |}} 


Una vez dibujado, se puede cambiar el tamaño del subtestcase con el pequeño cuadrado verde claro situado en la parte inferior de la derecha del subtestcase. Los subtestcases se pueden mover (seleccionándolo y arrastrándolo) en cualquier dirección. La única limitación al movimiento vertical es que no sobrepasen la línea de los adaptadores.\\ \\ 

{{ :es:subtestcase1.png?direct&400 |}}\\ \\ 


Para abrir las propiedades, doble click en el subtestcase y aparecerá la siguiente pantalla. Aquí se puede cambiar el nombre del subtestcase (hasta 100 caracteres) y añadir/editar una guardia. 
También se puede poner un nombre con una variable de forma que quedaría: “name of the subtestcase” + #Variable\\  También funcionaría como: ‘name of the subtestcase‘ + #Variable


{{ :es:stcesp3.png?600 |}}  

=== SubTestCases especificaciones ===

Hay algunas cosas a tener en cuenta usando subtestcases:

  - Todos los mensajes dentro de un subtestcase funcionarán como siempre en el diagrama, pero generará un log aparte para estos. Por lo que al final tendremos un log general y uno específico del subtestcase. Si se desea ver los logs desde el cliente se verá de la siguiente manera. \\ \\ {{:es:stcei4.png?600|}}\\ \\ Dentro de la carpeta tendremos el log del subtest y se generarán tantas carpetas como subtestcases existan en el diagrama.\\ \\ 
  - No se pueden anidar los subtestcases, solo se registrarán los logs de uno en caso de que estén anidados, así que, no usarlos de esa manera.
  - Dentro de un subtestcase se pueden poner pasos y fragmentos (combined fragments), estos fragmentos si pueden ser anidados.
  - Dentro de un fragmento se pueden poner subtestcases.
  - Los subtestcases pueden ser borrados, y también copiados y pegados.
  - Se pueden poner varios subtestcases en el mismo diagrama. 
   

=== SubTestCases en Gestión de Datos === 

En Gestión de Datos una vez se tenga un diagrama con un subtestcase (o varios) estos aparecerán marcados como un rectángulo rojo. 

{{ :es:stcesp5.png?600 |}} 

Gestión de Datos se usa como siempre pero con el añadido de ver los subtestcases.


=== SubTestCases en Resultados ===

En la página de resultados, una nueva funcionalidad ha sido añadida, con el simbolo: “+” puedes hacer click para desplegar una nueva tabla con todos los subtestcases que tiene una ejecución. Por ejemplo en las siguiente imagen.


{{ :es:stcei5.png?600 |}}

Podemos ver los resultados como siempre. Pero con el nuevo añadido:

{{ :es:stcei6.png?600 |}}

Podemos ver todos los resultados de subtestcases listados. Aquí se puede descargar los documentos de evidencias y los logs de los subtestcases.

En el documento de resultados:

{{ :es:stcei7.png?500 |}}


En test case data description, se puede ver el nombre del subtestcase, en caso de que el test case data tenga una descripción se mostrará “testcasedatadescription_subtestcasename”.


=== SubTestCase en ALM ===

En ALM se mostrarán todas las evidencias de la ejecución, y todos los subtestcases aparecerán por separado (también si hay gates con subtestcases aparecerán aquí).

{{ :es:stcei8.png?600 |}}
           
{{ :es:stcei9.png?600 |}}\\ \\ 


====Comentarios en diagramas====


Se ha incorporado un nuevo tipo de elemento en los diagramas: **el Comentario**.\\ \\ Un usuario que modela un diagrama podrá añadir comentarios en cualquier lugar del mismo, que le faciliten su comprensión cuando se trate de diagramas complejos.\\ \\ Los comentarios no serán tenidos en cuenta en la ejecución del diagrama, al igual que los comentarios en cualquier código fuente no son tenidos en cuenta ni por el compilador ni en la ejecución del código.


**Comentarios en Modeling**


Para dibujar comentarios en el diagrama, se incluye la nueva herramienta **Comentario** en el menú de herramientas de dibujo:\\ \\ {{ :es:comentarios_en_diagrama1.png?300 |}}\\ \\ Al hacer clic en el diagrama con esta herramienta se dibuja una caja con fondo gris donde podemos introducir el texto del nuevo comentario.\\ \\ También podemos usar el shortcut “ALT+C” para dibujar un comentario en el diagrama (ver tabla de shortcuts en la **ayuda del canvas**):\\ \\ {{ :es:comentarios_en_diagrama2.png?300 |}}\\ \\ Como cualquier elemento del diagrama, inicialmente la caja de comentario tendrá color rojo, que nos indica que aun debemos rellenar los campos del comentario, siendo entonces cuando la caja tendrá su fondo gris.\\ \\ {{ :es:comentarios_en_diagrama3.png?400 |}}


**Propiedades de un comentario**

Haciendo doble clic sobre un comentario o seleccionando la opción “Editar propiedades” del menú contextual (botón derecho del ratón sobre un elemento del diagrama), accedemos a la pestaña de propiedades para editar el comentario:\\ \\ {{ :es:comentarios_en_diagrama4.png?500 |}}\\ 
Un comentario incluye 3 campos:\\ 
  * **Nombre**: nombre del comentario. No se puede dejar vacío.
  * **Comentario**: el texto del comentario en sí. Se puede dejar vacío (no es obligatorio), aunque en este caso en el canvas aparecerá el cuadrado en rojo.
  * **Modo oculto**: si este checkbox está marcado, en la caja del comentario solo se muestra el nombre del comentario. Por el contrario, si el checkbox está desmarcado, en la caja aparece el nombre seguido del texto del comentario.  Por defecto siempre aparece desmarcado.\\ \\ Ejemplo del mismo comentario, en su modo normal (modo oculto desmarcado):\\ \\ {{ :es:comentarios_en_diagrama5.png?400 |}}\\ \\ Y en modo oculto:\\ \\ {{ :es:comentarios_en_diagrama6.png?400 |}}\\ 


**Diagrama con comentarios**

{{ :es:comentarios_en_diagrama7.png?500 |}}\\ \\ 
 
  * Un comentario puede dibujarse en cualquier lugar del diagrama ya que es un elemento flotante y no está asociado con ningún otro elemento del diagrama.
  * Un comentario puede ser desplazado por el canvas y cambiarse de tamaño.
  * El rectángulo del comentario intentará ajustarse automáticamente al texto que contiene.
  * Un comentario puede incluirse en una multiselección de elementos del canvas.
  * Un comentario se puede incluir en operaciones de copy/paste.
  * En la redistribución vertical del diagrama se tendrán en cuenta los comentarios que estén sobre las líneas de adaptadores, pero no aquellos que estén en la zona vacía del diagrama.
  * El contenido de los comentarios también se tiene en cuenta en las operaciones de búsqueda en el diagrama (ver botón **Buscar en diagrama**)\\ \\ {{ :es:comentarios_en_diagrama8.png?400 |}}\\ \\ 
   







 ==== Eliminar un mensaje ====
  
Cuando se desea eliminar un mensaje de un diagrama, TAST nos ofrece varias alternativas:\\ \\ 
La primera nos permite borrar el o los objetos del diagrama que se hayan seleccionado, haciendo click en el icono  papelera de la barra de herramientas. Aparece la siguiente ventana que cuenta con 2 posibles opciones a la hora de borrar (Borrar elementos y variables, Borrar elementos) y una opción de Cancelar/volver atrás.\\ \\ {{ :es:icono_borrar.png?direct&300 |}}\\ \\ {{ :es:eliminar_un_mensaje.png?link&500 |}}\\ \\ 
   * //Cancelar//: el mensaje no se elimina. La ventana de confirmación de eliminación está cerrada.
   * //Borrar elementos y variables//: se eliminan el mensaje y las referencias de las variables declaradas por ese mensaje. La ventana de confirmación de eliminación está cerrada.
   * //Borrar elementos//: sólo se elimina el mensaje, quedando las referencias de las variables declaradas por ese mensaje. La ventana de confirmación de eliminación está cerrada.\\ 

Una segunda sería haciendo click con el botón derecho del ratón sobre cualquier objeto del canvas, aparece un menú contextual dinámico, que presenta una serie de opciones dependiendo del tipo del objeto. Si se marca la opción “Delete”, aparece la misma pantalla anterior y se confirmara si se desea "Borrar elementos y variables", "Borrar elementos" o "Cancelar/volver atrás".\\ \\  
{{ :es:eliminar_un_mensaje1.png?direct&500 |}}\\ 

Y por último, podemos eliminar un elemento (esta opción sólo nos permite "Borrar elementos" o "Cancelar/volver atrás"), de una manera más rápida (atajo), utilizando el teclado. En este caso la tecla Supr.\\ Esta información sobre los atajos de teclado en el canvas, se mostrará al hacer click en el icono "?" de la barra de herramientas.
{{ :es:icono_mostrar_ayuda_del_canvas.png?direct&300 |}}\\ 
Y a continuación nos aparecerá toda la ayuda necesaria:
\\ \\ {{ :es:eliminar_un_mensaje2.png?link&300 |}}\\ \\


===== Información sobre la gestión de Diagramas UML =====

A continuación, **la pantalla para gestionar los diagramas UML**:\\ \\ 
{{ :es:diagrama_uml_2.0.png?link&800 |}}\\ \\ 

Podemos acceder a la información del diagrama pulsando el icono 'Más información'.\\ Se pueden paginar los diagramas mediante los números de página de la parte inferior de la pantalla.\\ \\ Esta pantalla permite:

 - [[es:Nuevo_diagrama:Crear un nuevo diagrama (//Nuevo diagrama// opción).]]\\ 
 - [[es:Salvar un diagrama:Guardar la versión en pantalla del diagrama (icono del disquette).]]\\ 
 - [[es:Borrar diagrama:Borrar un diagrama, usando el icono papelera.]]\\ 
 - [[es:Crear Nueva Carpeta:Crear una nueva carpeta (//+ Carpeta// opción).]]\\ 
 - [[es:Filtrar diagramas:Seleccionar diagramas usando los filtros de usuario y mapeos, mediante el icono ???.]]\\ 
 - [[es:Borrar filtras:Desactivar los filtros utilizados, usando el icono.]]\\ 
 - [[es:Editar diagrama:Editar un diagrama para su actualización, haciendo doble click.]]\\ \\ 


===== Pestaña Propiedades de mensajes =====

En la pestaña de asignación se establece la información en el nivel de mensaje:\\ 
  * Nombre: Nombre del mensaje.
  * Descripción: Descripción del mensaje.
  * Función predefinida: Función predefinida seleccionada (formar una lista combinada).
  * Parámetros de entrada: Dependiendo de tener o no parámetros de la PF seleccionada.\\ \\ {{ :es:propiedades_del_mensaje_1.png?link&500 |}}\\ \\ Para los parámetros de entrada hay dos puntos importantes a tener en cuenta:\\ \\  
        * Sensible: En caso de que se compruebe, significa que el parámetro es sensible a los caracteres. Es decir, no puede ver los caracteres cuando está configurando el valor de los mismos (más adelante, en la pestaña Asignación). Por ejemplo, esto es muy útil para las contraseñas, para ocultar los valores introducidos.\\ \\ {{ :es:propiedades_del_mensaje_2.png?link&500 |}}\\ \\  
        * Variable: En caso de que se compruebe, significa que el parámetro podría utilizarse más adelante en el diagrama como una variable. Una vez marcada la casilla de verificación aparece el símbolo # para indicar que este nombre será una variable desde ese momento.\\ \\ {{ :es:propiedades_del_mensaje_3.png?link&500 |}}\\ \\ 


===== Pestaña de Asignación de mensajes =====

La pestaña de asignación permite definir los parámetros de cada mensaje. Entonces, el “SearchBy” es la manera de encontrar un elemento en la sección de parámetros usando etiquetas, y el “Element”, es la ruta que se obtiene del SearchBy para indicar un elemento real e interactuar con él.\\ 
  * Elemento: Identificador del elemento HTML (relacionado con el atributo seleccionado en el campo SearchBy). Por ejemplo, XPath Identifier o CssSelector Identifier.
  * Buscar por: Atributo por el que se pregunta si se puede encontrar un elemento HTML. En el campo de SearchBy puedes elegir las siguientes opciones: ClassName, CssSelector, Id, LinkText, Name, PartialLinkText,TagName o Xpath y estas opciones son etiquetas que el usuario puede obtener de por ejemplo, el html de una pagina web en ciertos elementos. La mejor manera de obtener esta información es usando el F12 y buscando el elemento que queremos o usando la herramienta que hemos creado “Selective mapping”.\\ \\ Un Ejemplo visual de esto: Queremos pulsar el botón Amarillo.\\ \\ {{ :en:pulsarboton.png?500 |}}\\ \\ Para hacer eso con el F12, tienes que buscar el html del botón y guardar su SearchBy que es Id en este caso:\\ \\ {{ :en:botonid.png?500 |}}\\ \\ Por otra parte usando el selective mapping puedes escoger entre las siguientes opciones…\\ \\ {{ :en:botonidssm.png?300 |}}\\ Y para finalizar, añades los datos a tu diagrama.

  * Valor (opcional): Valor de entrada para meter en el control.\\ \\ 

===== Pestaña de Documentación de mensajes  =====

En un diagrama de TAST, los mensajes (pasos) que no sean de respuesta se pueden documentar mediante la pestaña “Documentación del mensaje” existente en las propiedades del mismo.

En esta pestaña se va a poder documentar todo lo que debe almacenarse en las herramientas de repositorio de evidencias como ALM, Confluence, etc.\\ \\ 
 
{{ :es:documentacion_del_mensaje.png?direct&700 |}}\\ 

Esta nueva pestaña contiene los siguientes elementos:\\ 

  * **Nombre del paso** 

  * **Documentar evidencias:** Este control indica si se deben obtener las evidencias (captura de pantalla, archivos, etc.) y si se debe registrar el paso en la herramienta de documentación (ALM, Confluence, etc.). Sólo se tomará una captura de pantalla al final de la ejecución de todos los parámetros del mensaje.

  * **Descripción del paso:** De manera predeterminada, la misma descripción que se ha hecho en las Propiedades del Mensaje, pero habrá la posibilidad de escribirlo y cambiarlo.

  * **Resultado esperado del paso:** De manera predeterminada está vacío o con OK, pero se podrá escribir lo que se quiera.

  * **Resultado de ejecución del paso:** Por el momento va a estar vacío.

  * **Archivos adjuntos:** Para pegar los archivos en la pestaña Documentación usando puede utilizar el acceso directo "Control + V" y arrastrando el ratón (ratón hacia abajo + ratón hacia arriba).

  * **Capturas de pantalla:** Para agregar una imagen en la zona de captura de pantalla desde el portapapeles, presione "Ctrl + V"; se abrirá una pantalla modal con la vista previa de la captura de pantalla y un campo para darle un nombre. No es necesario estar sobre ningún elemento, el evento de pegado funciona en cualquier lugar de la página de modelado, siempre y cuando haya una imagen en el portapapeles.\\ \\ **IMPORTANTE:**\\ Esta función no es compatible con Internet Explorer debido a las limitaciones de IE, por lo que debe realizarse con Chrome.\\ \\ 


===== Mover diagramas  =====

Esta opción de la herramienta TAST le permite al usuario mover un diagrama a otra carpeta de cualquier dominio y proyecto al que tenga acceso. Para poder usarlo, lo primero es ir a "Modelado" y hacer click en Diagramas UML. Se muestra la tabla, donde debe hacer click en el icono de flecha ubicado en la columna Acciones (cuarto elemento). Aparece una ventana emergente en la que selecciona el dominio, el proyecto y la carpeta donde desea mover el diagrama. Haga click en "sí". El diagrama se ha movido a esa carpeta.
 
 
{{:mover1.png?nolink&700|}}

{{:mover2.png?nolink&700|}}\\ \\ 

===== Variables globales =====

En un diagrama, es posible utilizar un conjunto de variables globales en todas las partes donde se permite la ayuda de variables (mapeo de objetos, mapeo de mensajes,....).\\ 

El menú desplegable de variables (incluidas las globales) aparecerá al escribir el carácter '#':\\ \\ 
{{ :es:desplegablevariablesglobales.png?direct&800 |}}\\ 
En TAST, actualmente existen estas variables globales:

  * **#caseResult:** variable booleana que contiene el resultado de la ejecución del caso de prueba:
       * correcto: cuando el resultado de la ejecución de todos los pasos del caso de prueba ha sido correcto.
       * incorrecto: de lo contrario; es decir, al menos la ejecución de un paso del caso de prueba ha sido fallida.
  * **#global_password:** Contiene la password de acceso al cliente.
  * **#global_user:** Contiene el usuario de acceso al cliente.
  * **#pathLog:** contiene la ruta de la carpeta, que contiene las capturas de pantalla, el archivo de registro y otros archivos generados durante la ejecución.
  * **#stepNumber:** Contiene un número de cuatro caracteres (ej. '0001') y representa el número con el cual se registrará el siguiente paso marcado para documentar en ALM. Cuando un paso se registre en ALM, este número se incrementará para el siguiente.
  * **#stepNumberTast:** Contiene la vieja numeración para documentar pasos en ALM antes de que la variable 'stepNumber' estuviera disponible. Este formato es "Step X.Y...Z Loop I.J...K"   siendo X...Z  la posición del paso,  donde Y...Z   son posiciones dentro de Gates,   e I...K   son el número de iteración de bucle,   donde J...K son el número de iteración de bucles anidados.
  * **#stepResult:** variable booleana que contiene el resultado de la ejecución del último paso en el caso de prueba:
       * correcto: cuando el resultado de la ejecución del último paso ha sido correcto.
       * incorrecto: de lo contrario; es decir, el resultado de la ejecución del último paso ha sido fallido.\\  
También podemos acceder de una manera rápida al listado de variables globales a través de la barra de herramientas. Al hacer click en el icono "?" nos aparecerá "Mostrar ayuda del Canvas".\\ \\ 
{{ :es:icono_mostrar_ayuda_del_canvas.png?direct&300 |}}\\ \\ 
A continuación un modal con 3 pestañas y elegimos la Pestaña “Variables globales” que muestra las variables globales estándar disponibles en cualquier diagrama.\\ \\ {{ :es:variables_globales.png?direct&300 |}}\\ \\

=====Funciones predefinidas - Generación de evidencias =====

A continuación, la lista de funciones predefinidas y la indicación de si generan evidencias o no: 


^Predefined Function ^Adaptor^Generates evidences^
|connect|Database|  NO  |
|connect_DB|Database|  NO  |
|dBExecuteStatement|Database|  NO  |
|dBGetQueryData|Database|  SI  |
|disconnect_DB|Database|  NO  |
|getNumColumns|Database|  NO  |
|getNumRows|Database|  NO  |
|getTableValue|Database|  NO  |
|tableRecordCount|Database|  NO  |
|addSheet|Excel File|  NO  |
|deleteSheet|Excel File|  NO  |
|generateFileAsEvidence|Excel File|  SI  |
|getCellValue|Excel File|  NO  |
|getColumnByRowSearch|Excel File|  SI  |
|getExcelSheet|Excel File|  NO  |
|getNumColumns|Excel File|  NO  |
|getNumRows|Excel File|  NO  |
|getNumValueSearchOnColumn|Excel File|  NO  |
|getRowByColumnSearch|Excel File|  SI  |
|getTableValue|Excel File|  NO  |
|getTableValueByColumnName|Excel File|  NO  |
|getValuesByPosition|Excel File|  NO  |
|newFile|Excel File|  NO  |
|setCellValueOneParameter|Ecxel File|  NO  |
|setColumnValues|Excel File|  NO  |
|setHeader|Excel File|  NO  |
|setRowValues|Excel File|  NO  |
|setTableValue|Excel File|  NO  |
|setSheet|Excel File|  NO  |
|vTableLookUp|Excel File|  SI  |
|vTableLookupArray|Excel File|  SI  |
|allOptionsAreSelected|GUI HTML|  SI  |
|clear|GUI HTML|  SI  |
|clearAndType|GUI HTML|  SI  |
|click|GUI HTML|  SI  |
|clickByJavaScript|GUI HTML|  SI  |
|clickLink|GUI HTML|  SI  |
|clickPrint|GUI HTML|  NO  |
|closeAllWindows|GUI HTML|  SI  |
|closeOthersWindows|GUI HTML|  NO  |
|closeWindow|GUI HTML|  NO  |
|countElements|GUI HTML|  NO  |
|checkbox|GUI HTML|  SI  |
|checkRadio|GUI HTML|  NO  |
|doubleClick|GUI HTML|  SI  |
|deleteAllCookies|GUI HTML|  NO  |
|deselectAllOptions|GUI HTML|  SI  |
|fileDownload|GUI HTML|  SI  |
|fileDownloadDialog|GUI HTML|  SI  |
|fileUpload|GUI HTML|  NO  |
|getAttribute|GUI HTML|  SI  |
|isCurrentUrlContains|GUI HTML|  SI  |
|isCurrentUrlEquals|GUI HTML|  SI  |
|isCurrentUrlMatches|GUI HTML|  SI  |
|isDisplayed|GUI HTML|  SI  |
|isExist|GUI HTML|  SI  |
|isSelected|GUI HTML|  SI  |
|isTitleEquals|GUI HTML|  SI  |
|isTitleMatches|GUI HTML|  SI  |
|hasOptionWithValue|GUI HTML|  SI  |
|javascriptAlertAccept|GUI HTML|  NO  |
|javascriptAlertCancel|GUI HTML|  NO  |
|javascriptExecute|GUI HTML|  NO  |
|login|GUI HTML|  SI  |
|openUrl|GUI HTML|  SI  |
|optionWithValueIsEnabled|GUI HTML|  SI  |
|optionWithValueIsSelected|GUI HTML|  SI  |
|pressEnter|GUI HTML|  SI  |
|select|GUI HTML|  SI  |
|selectAllOptions|GUI HTML|  SI  |
|selectOption|GUI HTML|  NO  |
|submit|GUI HTML|  SI  |
|tableCellValue|GUI HTML|  NO  |
|tableCellXPathByPosition|GUI HTML|  NO  |
|tableColumnsNum|GUI HTML|  NO  |
|tableHLookUpXPath|GUI HTML|  NO  |
|tableHtml|GUI HTML|  SI  |
|tableRowsNum|GUI HTML|  NO  |
|tableVLookUpValue|GUI HTML|  NO  |
|tableVLookUpXPath|GUI HTML|  NO  |
|takeScreenshot|GUI HTML|  SI  |
|type|GUI HTML|  SI  |
|typeAction|GUI HTML|  NO  |
|typeKeys|GUI HTML|  NO  |
|uncheckbox|GUI HTML|  SI  |
|validateAttribute|GUI HTML|  SI  |
|waitFor|GUI HTML|  NO  |
|waitForElement|GUI HTML|  NO  |
|waitForPageLoad|GUI HTML|  NO  |
|newConnect_Script|Script Generic|  NO  |
|execute_Script|Script Generic|  SI  |
|disconnect_Script|Script Generic|  NO  |
|connect_Script|Script Generic|  NO  |
|closeFile|Text Files|  NO  |
|containsText|Text Files|  NO  |
|countFileLine|Text Files|  NO  |
|countTextFile| Text Files|  NO  |
|deleteFtpFile|Text Files|  NO  |
|deleteSftpFile|Text Files|  NO  |
|generateFileAsEvidence|Text Files|  SI  |
|getFileText|Text Files|  NO  |
|getFtpFile|Text Files|  NO  |
|getLineLength|Text Files|  NO  |
|getNumColumns|Text Files|  NO  |
|getOwner|Text Files|  NO  |
|getReadLine|Text Files|  NO  |
|getSize|Text Files|  NO  |
|getSftpFile|Text Files|  NO  |
|getTableValue|Text Files|  NO  |
|getTextFileData|Text Files|  SI  |
|lineContainsText|Text Files|  NO  |
|loadCsvData|Text Files|  SI  |
|newFile|Text Files|  NO  |
|openFile|Text Files|  NO  |
|openNewFile|Text Files|  NO  |
|putFtpFile|Text Files|  NO  |
|putSftpFile|Text Files|  NO  |
|replaceText|Text Files|  NO  |
|writeEnter|Text Files|  NO  |
|writeTo|Text Files|  NO  |
|assertion|User Object|  NO  |
|compareParameters|User Object|  NO  |
|compareVariables|User Object|  NO  |
|copyFile|User Object|  NO  |
|dateAddition|User Object|  NO  |
|dateDifference|User Object|  NO  |
|dateWeekDay|User Object|  NO  |
|executeCommand|User Object|  NO  |
|executeJavaScript|User Object|  NO  |
|failTest|User Object|  NO  |
|getCurrentDate|User Object|  NO  |
|getCurrentDateAsDate|User Object|  NO  |
|getCurrentDateAsString|User Object|  NO  |
|isExistVariable|User Object|  NO  |
|manualTast|User Object|  SI  |
|removeVariable|User Object|  NO  |
|replaceAll|User Object|  NO  |
|saveRepositoryAsEvidence|User Object|  SI  |
|sendKeys|User Object|  NO  |
|sendKeysCombination|User Object|  NO  |
|sendKeysPaste|User Object|  NO  |
|setArrayVariable|User Object|  NO  |
|setVariable|User Object|  NO  |
|systemCloseProgram|User Object|  NO  |
|takeScreenshot|User Object|  SI  |
|waitFor:|User Object|  SI  |
|deleteRest|API/WebService|  SI  |
|getALLXMLElementValueByTagName|API/WebService|  SI  |
|getCookieValue|API/WebService|  NO  |
|getHeaderValue|API/WebService|  NO  |
|getHTMLElementValueByXPath|API/WebService|  NO  |
|getJSONElementValueByJsonPath|API/WebService|  NO  |
|getJSONElementValueByTagName|API/WebService|  NO  | 
|getRest|API/WebService|  SI  |
|getResponseStatus|API/WebService|  NO  |
|getResponseTime|API/WebService|  NO  |
|getXMLElementValueByXPath|API/WebService|  NO  |
|getXMLElementValueByTagName|API/WebService|  NO  |
|patchRest|API/WebService|  SI  |
|postRest|API/WebService|  SI  |
|putRest|API/WebService|  SI  |
|responseBodyContainsText|API/WebService|  NO  |
|setNoneAuthentication|API/WebService|  NO  |
|setBasicAuthentication|API/WebService|  NO  |
|setBearerTokenAuthentication|API/WebService|  NO  |
|setDigestAuthentication|API/WebService|  NO  |
|clearAndWriteField|Host 3270|  SI  |
|clearField|Host 3270|  SI  |
|containsText|Host 3270|  SI  |
|getLenghField|Host 3270|  NO  |
|nextScreen|Host 3270|  SI  |
|previousScreen|Host 3270|  SI  |
|readField|Host 3270|  SI  |
|readRow|Host 3270|  SI  |
|readScreen|Host 3270|  SI  |
|readScreenByRows|Host 3270|  SI  |
|rowContainsText|Host 3270|  SI  |
|waitCRC|Host 3270|  NO  |
|waitFor|Host 3270|  NO  |
|waitForChange|Host 3270|  SI  |
|waitForText|Host 3270|  SI  |
|writeAfterLabel|Host 3270|  SI  |
|writeBeforeLabel|Host 3270|  SI  |
|writeField|Host 3270|  SI  |
|writeKey|Host 3270|  SI  |
|writeKeyUntilFind|Host 3270|  SI  |
|writeText|Host 3270|  SI  |
|checkTextInSlide|PDF|  NO  |
|checkTextOnDocument|PDF|  NO  |
|checkTextOnPage|PDF|  NO  |
|checkTextOnPageArea|PDF|  NO  |
|generateFileAsEvidence|PDF|  SI  |
|getGetTextByPageArea|PDF|  SI  |
|getNumPages|PDF|  NO  |
|getNumWhitePages|PDF|  NO  |
|getPageAsImage|PDF|  SI  |
|getPageText|PDF|  SI  |
|getTextCountOnDocument|PDF|  NO  |
|getTextCountOnPage|PDF|  NO  |
|isPageWhite|PDF|  NO  |
|generateFileAsEvidence|XML|  SI  |
|getElementAttrTextByXPath|XML|  NO  |
|getElementsCountByTagName|XML|  NO  |
|getElementsCountByXPath|XML|  NO  |
|getElementsTextByTagName|XML|  SI  |
|getElementsTextByXPath|XML|  SI  |
|getElementTextByTagName|XML|  NO  |
|getElementTextByXPath|XML|  NO  |
|replaceElementAttrTextByXPath|XML|  NO  |
|replaceElementTextByTagName|XML|  NO  |
|replaceElementTextByXPath|XML|  NO  |
|saveAs|XML|  NO  |
|saveXml|XML|  NO  |
|xmlToString|XML|  NO  |
|executeAllServiceOperations|SOAP UI|  SI  |
|executeAllTestSuite|SOAP UI|  SI  |
|executeServiceOperation|SOAP UI|  SI  |
|executeTestCase|SOAP UI|  SI  |
|executeTestStep|SOAP UI|  SI  |
|executeTestSuite|SOAP UI|  SI  |
|executePostmanCollection|Postman Collection|  SI  |
|getResponseBody|Postman Collection|  SI  |
|getResponseStatusCode|Postman Collection|  SI  |
\\  

===== Atajos =====

Para acelerar la fase de modelado, TAST ofrece un conjunto de atajos:
\\ 

^Atajo            	^Descripción^
|Esc  | Cierra los menús y selecciona el puntero.|
|Supr  | Borra elementos si hay uno o más seleccionados.|
|Alt + 9 | Desbloquear diagrama para edición.|
|Alt + P | Selecciona la herramienta puntero.|
|Alt + O | Selecciona la herramienta "Objeto".|
|Alt + M | Selecciona la herramienta "Mensaje".|
|Alt + R | Selecciona la herramienta "Mensaje de respuesta".|
|Alt + G | Selecciona la herramienta "Gate".|
|Alt + A | Selecciona la herramienta "Fragmento Combinado: ALT".|
|Alt + D | Selecciona la herramienta "Fragmento Combinado: DO WHILE".|
|Alt + W | Selecciona la herramienta "Fragmento Combinado: WHILE".|
|Alt + F | Selecciona la herramienta "Fragmento Combinado: FOR".|
|Alt + E | Selecciona la herramienta "Fragmento Combinado: FOR EACH".|
|Alt + S | Selecciona la herramienta "Subtestcase".|
|Ctrl + C| Copiar elementos seleccionados.|
|Ctrl + V| Pegar elementos copiados.|
|Ctrl + Shift + V| Pegar los elementos copiados en la posición que indique el cursor.|
|Ctrl + Z| Deshace algunas acciones como (Borrar elementos, Redistribuir diagrama, etc...|
|Ctrl + Shift + F| Comentar/descomentar los elementos seleccionados (mensajes/gates).|
|Double click | Editar elemento: haga doble click sobre un elemento del diagrama para editar sus propiedades.|
|Right button | Menú contextual: pulsando el botón derecho del ratón sobre un elemento, se accede al menú contextual dinámico. Las opciones de este menú varian y pueden aparecer activas/no activas, dependiendo de los elementos actualmente seleccionados.|
|Mouse Wheel  | Zoom in/Zoom out: mueva la rueda del ratón hacia adelante o hacia atrás, para alejar o acercar el canvas respectivamente.|
|Shift + click| Selección múltiple: mantenga pulsada la tecla "shift" y haga click en distintos elementos para seleccionarlos.|
|Shift + drag | Desplazamiento múltiple: mantenga pulsada la tecla "shift" mientras desplaza los elementos seleccionados.|
|Click + drag | Desplazar diagrama: haga click en una zona vacía del diagrama mientras arrastra en cualquier dirección para mover el diagrama.| 
\\ \\ 

===== Selección múltiple de mensajes =====

===Selección de objetos en el Canvas====

Seleccionando un objeto, podremos a continuación realizar otras acciones con él (p.ej. borrarlo, copiarlo, moverlo, etc.)\\ 
===Selección simple===
Para seleccionar un objeto del Canvas basta hacer **click** encima del objeto (en cualquiera de sus partes, incluido el texto).\\ 
Para deseleccionarlo, basta con hacer click en una zona “vacía” del Canvas.\\ 
===Selección múltiple===
Para seleccionar varios objetos en el Canvas, pulsaremos **shift-click** sobre los distintos objetos que queremos ir seleccionando.\\  
Esto nos permite realizar acciones sobre ese grupo de objetos seleccionados (p.ej. borrarlos, moverlos, copiarlos, etc.)
Para deseleccionarlos, basta con hacer click en una zona “vacía” del canvas.\\ 
En la selección múltiple no hay limitación en cuanto al tipo de objetos seleccionados, es decir, se pueden seleccionar a la vez todo tipo de objetos (mensajes, gates, fragments…)\\ 
\\ \\ 
===== Mapeo Selectivo =====

TAST cuenta con una importante ayuda a la hora de hacer el mapeo de los objetos y los mensajes en un diagrama: el Mapeo Selectivo.

La configuración, cómo utilizar la funcionalidad, y algunas consideraciones se explican en el siguiente documento:
 
{{:es:tast_mapeo_selectivo_2024.doc|}}



===== Gestión de TastTableData =====

En un diagrama UML, TAST permite el uso de variables de un tipo específico de tabla, llamado **TastTableData**. 

Estas variables pueden ser utilizadas con prácticamente todos los adaptadores disponibles en TAST (HTML GUI, Archivos Excel, Base de datos,...). Se pueden utilizar en la casilla "Valor" de una función predefinida o en Javascript.\\ \\ Una vez creadas las variables **TastTableData** (como variables de salida), podrán ser utilizadas como variables de entrada en los mensajes posteriores. La forma de utilizarlos en una "caja de valores" es:\\ #TasTableDataVariableName.functionName(params...). Desde javascript, se utilizará la sintaxis functionName(params...)\\ \\ Las funciones actualmente disponibles son:

^ Output ^ Function ^ Description^
|String|**getDateWithFormatFromCellValue(int row, int column, String format)**|A partir de una celda (identificada por fila y columna) cuyo contenido es de tipo DATE (dd/MM/yyyy HH:mm:ss) obtiene dicho valor o contenido en el formato indicado. Dicho formato tiene que ir entre comillas.{{ :en:datetype.png?700| }}|
|int|**getNumColumns()**|Devuelve un número entero con el número de columnas.|
|int| **getNumRows()** |Devuelve un número entero con el número de filas.|
|String| **getStringValue()** |Devuelve una cadena que contiene el contenido de la tabla separando las celdas con <nowiki>|</nowiki> y las filas con <nowiki>||</nowiki>.|
|TastRowTableData| **getTheRow(int index)**|Devuelve una línea.|
|N/A|**addRowData(TastRowTableData rowData)**|Agrega una fila al final de la tabla.|
|TastRowTableData| **getTheColumn(int index)**|Devuelve una columna (como una línea).|
|TastDataGeneric| **getCellValue(int row,int column)** | Devuelve el valor de una celda específica.|
|TastDataGeneric| **getTableValueByColumnName(int rowNum, String columnName)** |Devuelve el valor de una celda identificada por el número de línea y el nombre de columna.|
|N/A|**setTableValue(int row, int column, String value)**|Permite añadir un valor a una celda específica. El valor puede ser una cadena, un valor Float o Booleano, ya sea contenido o en una variable o en un código duro:|

TastTableData es una lista multidimensional, o una lista de listas. Al colocar una lista dentro de otras, podemos guardar información en filas y columnas. Vamos a mostrar un ejemplo:

Con la función **SetVariable** vamos a definir una variable de tipo **TastTableData**.\\ \\

{{ :es:tasttabledata1.png?direct&600 |}}\\ \\ {{ :es:tasttabledata2.png?direct&600 |}}\\ 

Aparecen las distintas filas, que contiene cinco columnas, cada una de un tipo. Se pueden añadir más filas.\\ \\ {{ :es:tasttabledata3.png?direct&600 |}}\\ \\ Para obtener toda la información que hay en la primera página del fichero Excel, podemos utilizar la función **getExcelSheet** y se guarda en esta variable TastOutputTable.\\ \\ {{ :es:tasttabledata4.png?direct&600 |}}\\ \\ {{ :es:tasttabledata5.png?direct&600 |}}\\ \\ Después para poder trabajar con TastOutputTable podemos utilizar las funciones o métodos arriba expuestos.  

===== Gestión de TastRowTableData=====

TAST permite el uso de variables de un tipo específico de fila, llamado **TastRowValues**.\\ 

Estas variables pueden ser utilizadas con prácticamente todos los adaptadores disponibles en TAST (HTML GUI, Archivos Excel, Base de datos,...). Se pueden utilizar en la casilla "Valor" de una función predefinida o en Javascript.\\ \\  Una vez que las variables **TastRowValues** han sido creadas (como variables de salida), pueden ser utilizadas como variables de entrada en mensajes posteriores.\\ \\  La forma de utilizarlos en una "caja de valores" es: #TastRowDataVariableName.functionName(params...) Desde javascript, se utilizará la sintaxis functionName(params...)\\ \\ Para poder trabajar con estas variables, se han creado unos métodos o Funciones Predefinidas. Las funciones actualmente disponibles son:

^ **Output** ^ **Function** ^ **Description**^
|N/A|**addCellValue(String value)**|Permite añadir una celda al final de TastRowValues.|\\ 
|String| **getCellValue(int index)**|Devuelve el contenido de una celda específica.|
|String|**getDateWithFormatFromCellValue(int row, int column, String format)**|A partir de una celda (identificada por columna) cuyo contenido es de tipo DATE (dd/MM/yyyy HH:mm:ss) obtiene dicho valor o contenido en el formato indicado. Dicho formato tiene que ir entre comillas.{{ :en:datetype.png?700| }}|
|int| **getLength()**|Devuelve el número de celdas de los datos de TastRowValues.|
|String|**getStringValue()** |Devuelve el contenido de la fila que separa las celdas con <nowiki>|</nowiki>|. 

TastRowTableData es una colección de datos en forma de lista que pueden repetirse. El número de elementos no está 
fijado ni limitado por anticipado. Para acceder a los elementos se utiliza un índice que indica la posición del elemento en la colección. Este tipo de datos es necesario en varios Adaptadores.\\ \\  Ponemos un ejemplo con dos Adaptadores: Adaptador de Usuario y Adaptador Excel. En el Adaptador de Usuario vamos a crear una variable de este tipo. Se utiliza el Método o la Función Predefinida **SetVariable**, para ello solo hay que elegir el tipo de dato:  TastRowValue y rellenar.\\ \\ \\ {{ :es:tastrowtabledata0.png?direct&800 |}}\\ \\ {{ :es:tastrowtabledata1.png?direct&800 |}}\\ \\ {{ :es:tastrowtabledata2.png?direct&400 |}}\\ 
En este otro ejemplo (mensaje) se recoge de un fichero Excel a través del Adaptador Excel, la columna cuya fila cumple una condición. El resultado se guarda en este tipo de dato, en la variable OUTPUT.\\ \\ {{ :es:tasrowtabledata4.png?direct&800 |}}\\ \\ 
En este otro ejemplo (mensaje) vemos que vamos a utilizar la variable OUTPUT y vamos a obtener la celda de índice uno, con estos métodos o Funciones Predefinidas, la primera celda es el uno, no es el cero.\\ \\ {{ :es:tastrowtabledata3.png?direct&800 |}}\\ \\ 


Para más información sobre la Gestión de Variables, ver el apartado [["es:Variable_Management.]]\\ \\ 

=====  TAST Canvas 2.0 =====

TAST tiene una característica importante: el Canvas, que es un lugar donde el usuario puede pintar los diagramas UML.\\ \\ 
En realidad, el flujo de trabajo del uso de TAST comienza desde su Canvas.\\ \\ 
Actualmente Canvas/Modeling 2.0 no funciona en Internet Explorer, debido a que IE es un producto descontinuado.
El resto de navegadores Chrome, Edge y Firefox si son compatibles.\\ \\ Puedes lanzar el Canvas desde varios lugares: 
  * Creación de un nuevo diagrama UML. 
  * Edición de un diagrama existente.
  * Navegación desde varios lugares de TAST para consultar un diagrama.\\ \\ 
{{ :es:canvas01.png?direct&550 |}}\\ \\ 


Hemos creado una página donde se explica con detalle, su uso, las mejoras realizadas y todas las funcionalidades que tiene.  {{:es:flecha_acceso.png?50|}} [[TAST Canvas 2.0]] \\ \\ 



 








===== Gestión de datos =====

Mediante esta opción se podrán gestionar los conjuntos de datos con los que se lanzarán las pruebas correspondientes a un diagrama específico.

La opción de Gestión de datos consta de tres pestañas:
  * Datos de los conjuntos de pruebas.
  * Datos del equipo de prueba.
  * Información de datos de los conjuntos de pruebas.\\ \\ 

==== Ventana Datos de los Conjuntos de Prueba ====

{{ :es:gestion_de_datos1.png?direct&700 |}}\\ \\ 
Muestra la lista de los diagramas de un dominio y proyecto concreto, con información sobre sus conjuntos de datos de casos de prueba y conjuntos de casos de prueba.
A nivel general, se podrá filtrar por:
  *	Dominio.
  *	Proyecto.
  *	Diagrama.
  *	Usuario.
También se permitirá modificar y eliminar una carpeta.

En la ventana principal de GESTIÓN DE DATOS se visualizará la lista de diagramas para los filtros empleados, con la siguiente información:
  * 	Fecha de creación.
  *	Número de conjuntos de datos de casos de prueba.
  *	Número de conjuntos de casos de prueba.
  *	Acción: con los siguientes indicadores:
     *	Subido a ALM. 
     *	Usuario propietario.
     *	Más información: al hacer click en esta opción, se abre la ventana de Test Set Data Info.\\ \\ 
==== Ventana Datos del Equipo de Pruebas ==== 

{{ :es:gestion_de_datos2.png?direct&700 |}}\\ \\ 
En esta ventana se crearán los datos de los casos de prueba de un diagrama.
A ella se accede haciendo click sobre cualquier diagrama de la ventana //Test Sets Data//.

Existirá un conjunto de datos de validación y 1 a n conjuntos de datos de valores.
Se podrá indicar :
  * La descripción del Test case data.
  * El tipo de prueba (positivo ó negativo).
  * Los valores para los parámetros de los objetos.
  * Los valores para los parámetros de los mensajes.

También se podrá visualizar el diagrama.

Existirá la opción de copiar los datos de los casos de pruebas, que posteriormente podrán ser modificados.\\ \\ 

==== Ventana Información de Datos de los Conjuntos de Pruebas ==== 

Hay dos formas de acceder a esta Ventana de Información:\\ 
  * Seleccionando directamente dicha pestaña.\\ \\ {{ :es:gestion_de_datos3.png?direct&700 |}}\\ \\ o bien\\ \\  
  * Seleccionando el icono //Más información// de un diagrama.\\ \\ {{ :es:gestion_de_datos4.png?direct&700 |}}\\ 

Esta nueva Ventana de Información, nos proporcionará la información relativa a:\\ 
       * Usuario propietario. 
       * Ruta donde se encuentra el diagrama.
       * Fecha de creación.
       * Nombre del diagrama.
       * Número de conjuntos de datos de casos de prueba.
       * Número de conjuntos de casos de prueba y su ruta.\\ \\ 

==== Funcionalidad Borrar ====
En la Ventana de Test Set Data, tenemos otra funcionalidad para borrar Test Case Data (TCD) de forma masiva, creados para ese Test Set (TS).\\ \\ 
Un nuevo icono con una papelera dentro ha sido colocado en la barra superior derecha.\\ 

{{ :es:borrar_text_case_data_1.png?direct&250 |}}\\  
Cuando este botón es presionado, aparece una ventana modal con una lista de todos los TCD.\\  

{{ :es:borrar_test_case_data_2.png?direct&650 |}}\\ 

Características de esta ventana modal:
  * Cada TCD tiene un checkbox.
  * Estos checkbox pueden ser seleccionados haciendo click en ellos. Permanecerán seleccionados a no ser que vuelvan a ser clickados.
  * También, puedes seleccionar multiples TCD si aprietas shift mientras eliges dos TCD separados. También se pueden elegir varios segmentos volviendo a hacer click en otro alejado de los demás segmentos.
  * Tenemos un checkbox de “select all” que, como el nombre dice, selecciona y deselecciona todos los TCD.
  * Para cerrar la ventana modal sin realizar cambios, puedes tanto cerrarla con la cruz de arriba a la derecha o pulsando el botón de “No”.
  * Finalmente, para borrar todos los TCD seleccionados, se pulsa el botón “Borrar”. La ventana modal se cerrará una vez los cambios estén realizados. Si quieres guardar los cambios definitivamente se tendrá que guardar el TS.\\ \\   




 



==== Importar TCD desde un fichero Excel ==== 

En esta página se puede importar datos de un archivo de Excel. Basta con hacer click en el icono Importar para mostrar la página "Importar archivo TC".\\ 

{{ :es:importar_archivo_de_tcd1.png?direct&650 |}}\\ \\ 
Entonces, 
  - Debe proporcionar un archivo de Excel con el orden correcto de los datos. 
  - Para fijar en la página, la correspondencia entre la columna del fichero Excel (A, B, etc.) y el campo relacionado Descripción, Tipo de prueba, etc.

Después de seleccionar el archivo y establecer la correspondencia, haga click en el botón Importar para realizar el proceso de importación.\\ \\ 
{{ :es:importar_archivo_de_tcd2.png?direct&650 |}}\\ 


===== Cómo buscar un diagrama UML en Modelado =====	

Esta opción de TAST permite al usuario realizar una búsqueda de un diagrama entre todos los dominios de la aplicación. TAST también permite filtrar el Conjunto de Pruebas en la Gestión de TS en todos los dominios.\\ 

Para utilizar la búsqueda de un diagrama UML, haga click en el botón de filtro de todos los dominios y proyectos.\\ \\ 

{{ :es:buscar_diagrama_uml_en_modelado1.png?direct&650 |}}\\  

Nos aparecerá la siguiente pantalla\\ 

{{ :es:buscar_diagrama_uml_en_modelado2.png?direct&650 |}}\\ 

Podemos elegir entre los dos tipos de búsqueda:\\ 
  * por ID de diagrama.
  * por nombre (parcial o total) del diagrama.\\ \\ 

** Búsqueda por ID de diagrama **

En el campo //búsqueda// (//search//) escriba el ID del diagrama de la búsqueda que desea realizar y haga click en el botón de la lupa. La aplicación muestra el diagrama con el ID especificado en la búsqueda.\\ \\ 
{{ :es:buscar_diagrama_uml_en_modelado3.png?direct&650 |}}\\  
Si hace click en el icono del archivo, el diagrama se abrirá directamente:\\ 
{{ :es:buscar_diagrama_uml_en_modelado4.png?direct&650 |}}\\ \\

** Búsqueda por el nombre del diagrama **

En el campo //search// escriba los caracteres de la búsqueda que desea realizar y haga click en el botón de la lupa. La aplicación muestra todos los diagramas de todos los dominios que contienen los caracteres introducidos en la búsqueda.\\ \\ 

{{ :es:buscar_diagrama_uml_en_modelado5.png?direct&650 |}}\\ \\ 

{{ :es:buscar_diagrama_uml_en_modelado6.png?direct&300 |}}

Si hace click en el icono de la lista, la aplicación cambiará al Diagrama, Dominio y Proyecto seleccionado:\\ \\ 

{{ :es:buscar_diagrama_uml_en_modelado7.png?direct&640 |}}\\ \\ 


===== Como buscar un diagrama UML en Gestión de Datos =====

Esta opción de TAST permite al usuario realizar una búsqueda de un diagrama (y sus Datos de Caso de Prueba) entre todos los dominios de la aplicación. TAST también permite filtrar el Conjunto de Pruebas en la Gestión de TS en todos los dominios.\\ \\ Hay dos tipos de búsquedas:\\ 
  * por ID de diagrama.
  * por nombre (parcial o total) del diagrama.

Para utilizar la búsqueda de un diagrama UML, en la Gestión de Datos, siga estos pasos:\\ \\ En Modelado, seleccione la Opción de Gestión de Datos.\\ \\  
{{ :es:buscar_diagrama_uml_en_gestion_de_datos1.png?direct&650 |}}\\ 

Haga click en el botón de filtro de todos los dominios y proyectos.\\ \\  
{{ :es:buscar_diagrama_uml_en_gestion_de_datos2.png?direct&650 |}}\\ \\ 


**Buscar por el ID del diagrama**

En el campo //search// escriba el ID del diagrama de la búsqueda que desea realizar y haga click en el botón de la lupa. La aplicación muestra los Datos del Conjunto de Pruebas correspondientes al diagrama con el ID especificado en la búsqueda.\\  

{{ :es:buscar_diagrama_uml_en_gestion_de_datos3.png?direct&650 |}}\\ \\ 
 
Si hace click en el icono del archivo, los Datos del Conjunto de Pruebas se abrirán directamente:\\ 

{{ :es:buscar_diagrama_uml_en_gestion_de_datos4.png?direct&650 |}}\\ \\ 


**Buscar por el nombre del diagrama** 

En el campo //search// escriba los caracteres de la búsqueda que desea realizar y haga click en el botón de la lupa.\\ \\ 
{{ :es:buscar_diagrama_uml_en_gestion_de_datos5.png?direct&650 |}}\\ 

La aplicación muestra todos los diagramas de todos los dominios que contienen los caracteres introducidos en la búsqueda.\\ \\ 
{{ :es:buscar_diagrama_uml_en_gestion_de_datos6.png?direct&400 |}}\\ \\ 
Si hace click en el icono de la lista, la aplicación cambiará a los Datos del Caso de Prueba, Dominio y Proyecto seleccionados:\\ 

{{ :es:buscar_diagrama_uml_en_gestion_de_datos7.png?direct&650 |}}\\ \\ 

Haciendo click en el diagrama, puede ver los Datos del Caso de Prueba del diagrama seleccionado.\\ \\ 
{{ :es:buscar_diagrama_uml_en_gestion_de_datos8.png?direct&650 |}}\\ \\ 



=====Gestión de Repositorios=====

Este apartado, es donde se van a gestionar todos los repositorios usados en los diagramas.
Los repositorios son archivos YML o TXT (deben tener formato YML/YAML) que creamos y subimos a esta página de repositorios y que contienen una serie de claves que podremos usar en los diagramas.

====Glosario====

Para evitar confusiones con la funcionalidad de la creación de repositorios debemos tener claro qué significa cada parte de los repositorios; para esto vamos a poner un ejemplo detallado.\\ \\ 
Conceptos (a la hora de crear un repositorio):\\  
  * **Archivo:** Es un fichero de texto o YML/YAML en el cual se introducen el código para usar el repositorio. Cabe mencionar que si no tenemos un entorno (como Notepad++ u otros) con transformación de tabulador en espacios, el archivo no funcionará si se usa el tabulador para hacer saltos de espacios en la línea, se tendrán que hacer pulsando múltiples veces el espacio porque la sangría con tabulador no funciona en YML.\\ 
  * **Claves:** Son cada una de las palabras que van antes de los “ : ”\\ 
  * **Propiedad:** Es la ruta completa formada con las claves hasta los “ : ” usando “ _ ” para separarlas.\\ 
  * **Valor:** Es lo que aparece después del “ : ” \\ 
Ejemplo:{{ :es:xpath1.png?600  |}}

También, se pueden hacer subclaves:{{ :es:xpath2.png?600  |}}

Por lo que al final la variable estará compuesta de las propiedades separadas por “_”, en el caso del ejemplo: #wiki_url1.

La primera clave siempre sera una de las siguientes:
{{ es:repo11esp.png?200  |}}\\ 

====Características====

En la gestión de repositorios tenemos diferentes “características” con las que podemos contar:

  * Importar repositorios que sean TXT e YML. Los repositorios están definidos por claves. Estos repositorios deben tener una clave en el primer nivel la cual será una de las opciones del “searchBy” listadas en los mensajes de un diagrama. Luego tendrá una segunda clave que será un nombre identificativo y por último se colocará el valor, que es la ruta según el tipo de searchBy que estemos usando, (estas claves no son “case sensitive”, sin embargo, a la hora de ponerlo en el campo element del mensaje tiene que estar exactamente igual al repositorio).\\ \\ Un ejemplo de esto sería:\\ {{ :es:xpath3.png?800  |}}\\    
  * Exportar repositorios como archivos YML que tenemos guardados ya en este apartado.
  * Abrir, editar, borrar y guardar repositorios.
  * Crear, editar y borrar las carpetas donde se contendrán dichos repositorios. Una carpeta que contenga repositorios no podrá ser borrada si no se eliminan de ahí antes (y con la excepción de la carpeta por defecto).
  * Clonar un repositorio ya importado en otro nuevo.
  * Ver información sobre los repositorios tales como fecha de creación y diagramas que lo utilizan, similar a la pestaña de “más información” de modelado.
  * Ver donde se está usando un repositorio que está siendo usado.\\ 

====Importar repositorios====

En la página de gestión de repositorios, tenemos que pulsar el botón de importar arriba a la derecha.\\ \\  

{{ :es:gestion_de_repositorios0.png?direct&650 |}}\\ \\ 
Después se abrirá una ventana modal.\\ \\  
{{ :es:gestion_de_repositorios1.png?direct&300 |}}\\ 
En esta ventana modal elegiremos el nombre del repositorio, en que dominio y proyecto lo queremos y en que carpeta guardarlo.\\ \\  
{{ :es:gestion_de_repositorios2.png?direct&300 |}}\\  

Completados todos los datos requeridos, le daremos a importar.\\ \\ 
Si el archivo TXT /YML está correcto, se importará perfectamente, cómo vemos en la imagen siguiente.\\ \\ 

{{ :es:gestion_de_repositorios3.png?direct&650 |}}\\ \\ 
Si no se ha podido importar, aparecerá el siguiente mensaje:\\ \\  

{{ :es:repo10esp.png?250  |}}\\ \\ 

Esto puede pasar por diferentes motivos:
  * el formato del TXT no sea YML/YAML
  * hay algún error en el archivo o
  * la sintaxis del yml en el repositorio es incorrecta, como insertar espacios con tabulador en lugar de barra espaciadora o utilizar una clave como subclave de otra, cuando el valor ya está definido. Para evitar esto último se tendría que usar un editor como (Notepad++) con la opción de convertir la tabulación en espacios.\\ \\ 


====Cambios en Modelado====

En el apartado de Modelado se pueden apreciar distintos cambios con respecto a los repositorios.
  * La pestaña de propiedades del diagrama ha sido actualizada para mostrar desde ahora, información en la parte derecha sobre repositorios.
  * Desde esta parte el usuario puede añadir repositorios, pulsando el botón de editar.\\ \\ {{ :es:gestion_de_repositorios4.png?direct&650 |}}\\ \\ 
  * Después de pulsado el botón de editar, se desplegará una ventana modal, como se muestra en la siguiente imagen. A través de Dominio, Proyecto y carpeta, buscaremos los repositorios disponibles.\\ \\ {{ :es:gestion_de_repositorios5.png?direct&400 |}}\\ \\ 
  * Podemos añadir o eliminar los repositorios que deseemos. Y una vez aceptado, se guarda y se actualiza el diagrama con los repositorios de la sección “Repositorios seleccionados”, lo cual elimina del diagrama los que estaban y se quitaron, y añade los que no estaban y se agregaron. Pese a que los repositorios estén inmediatamente disponibles tras seleccionarlos, la relación Repositorio-Diagrama no se confirma hasta que el Diagrama se guarde.\\ \\ {{:es:gestion_de_repositorios6bis.png?direct&290|}} {{ :es:gestion_de_repositorios7bis.png?direct&300|}}\\ \\ 
  * Para eliminar un repositorio desde las propiedades del diagrama, primero se selecciona el repositorio elegido y después se pulsa el botón del cubo de la basura. Este se eliminará junto con todas las conexiones a mensajes que tenga.\\ \\ {{ :es:gestion_de_repositorios8.png?direct&500 |}}\\ \\ 
  * Para ir directamente a un repositorio, solo hay que pulsar en su nombre y se abrirá una pestaña nueva en Gestión de Repositorios con acceso directo al mismo.\\ \\ {{ :es:gestion_de_repositorios9.png?direct&500 |}}\\ \\ {{ :es:gestion_de_repositorios10.png?direct&500 |}}\\ \\ 
  * En el apartado de mensajes también hay actualizaciones. Como se puede observar en la imagen se ha añadido un campo desplegable “Repositorio” desde el cual, se podrá elegir el repositorio que se desea usar en ese parámetro. Una vez elegido el repositorio, el siguiente paso es elegir en el campo SearchBy “Repository”. Y en el campo “Element” se pueden utilizar las claves del repositorio como variables tras escribir almohadilla “#”, y tener Repositorio y searchBy seleccionados.\\ \\ {{ :es:gestion_de_repositorios11.png?direct&500 |}}\\ \\ {{ :es:gestion_de_repositorios12.png?direct&500 |}}\\ \\ 
   
   *  Una vez pones la almohadilla es posible autocompletar con las claves del repositorio, como se muestra en la imagen siguiente. Para usar estas claves, las variables se generan concatenando los niveles de las claves con “_” (barra baja), hasta llegar al valor por lo que las claves deberán ser usadas como variables separadas por “_” como se muestra en el apartado de glosario.\\ \\ {{ :es:gestion_de_repositorios13.png?direct&500 |}}\\ \\ 
  
   * Como nota importante, no usar en los nombres de las propiedades del repositorio nombres compuestos por “_” ya que a la hora de concatenar estos, podría ocasionar algún error.\\ 



=====Gestión de Bibliotecas====

====Introducción====

La Gestión de Bibliotecas proporciona a TAST y en concreto a la parte del modelado de diagramas, una herramienta para el manejo de bibliotecas, mediante la cual se puedan almacenar, organizar y consultar funciones javascript ó queries Sql, que el usuario considere que son de utilidad, por ejemplo para ser reusadas en los mensajes de otros diagramas.

Funciones predefinidas como por ejemplo executeJavascript o dbGetQueryData, son ejemplos de mensajes que incluyen un código javascript ó a una query sql: 
 

 

 
====Página de Gestión de Bibliotecas====

===Menú Gestión de Bibliotecas===

Puesto que se trata de una herramienta de apoyo al modelado de diagramas, encontramos la Gestión de Bibliotecas como un submenú dentro del menú principal Modelo:
 


 
Pantalla Gestión de Bibliotecas
En esta pantalla podemos crear y catalogar, editar y hacer consultas sobre los ítems de biblioteca:
 

A continuación veremos cada una de las distintas funcionalidades de la pantalla.


 
Crear  nuevo ítem de biblioteca
   Pulsando este botón en la parte superior derecha de la pantalla, aparece un formulario donde el usuario rellenará los campos para dar de alta el nuevo ítem de biblioteca. 
 
Todos estos campos son obligatorios y no se pueden dejar vacíos.
A continuación vemos dichos campos:
1.	Dominio y Proyecto
El usuario debe seleccionar un dominio, y dentro de él un proyecto para el nuevo ítem. Todos los usuarios pertenecientes a ese dominio tendrán acceso a los ítems de biblioteca guardados en él.
2.	Tipo
Este campo permite elegir el tipo de ítem que se va a crear, que será uno de estos dos: 
•	Javascript function
•	Sql Query
3.	Nombre
Campo de texto para introducir un nombre lo suficientemente descriptivo que identifique al ítem y que posteriormente facilite las búsquedas. No puede contener espacios.
 
4.	Etiquetas
Campo de texto para introducir uno o varias etiquetas (separadas por comas) lo suficientemente descriptivas que posteriormente faciliten su catalogación y búsquedas. 
5.	Descripción
Campo de texto para introducir una descripción lo suficientemente descriptiva que posteriormente facilite la comprensión del contenido. Por ejemplo, en el caso de una función javascript, se puede describir brevemente qué hace la función, qué parámetros recibe y que resultado devuelve.
6.	Contenido
Haciendo click sobre este campo, se expande y nos lleva a una ventana modal con el editor de código especial para introducir código Javascript o Sql. 
Este editor admite eventos copiar/pegar desde cualquier otro editor.
 

Selección de Dominio
 
En la pantalla Gestión de Bibliotecas inicialmente aparecerán en la lista los ítems pertenecientes al Dominio actual.  Todos los usuarios que pertenezcan a dicho dominio tendrán acceso a los ítems de bibliotecas almacenados en él.


Filtros: búsquedas para localizar ítems en las bibliotecas
 
Como se ha dicho, inicialmente aparecerán en la lista todos los ítems pertenecientes al dominio actual. 
Posteriormente el usuario puede refinar su búsqueda usando cualquiera de los filtros que se le proporcionan, individual o conjuntamente. 
1.	Proyecto
Se pueden filtrar los resultados según su proyecto, por defecto se mostrarán todos los ítems del dominio y de cualquier proyecto dentro del mismo.
2.	Tipo
Se muestran los resultados según su tipo: Javascript code o Sql query.
3.	Nombre
Si se desea filtrar resultados por el nombre del ítem, escriba una cadena en este campo y pulse ENTER para aceptar. En la lista se mostrarán los ítems cuyo nombre sea igual o contenga la cadena introducida en este campo.
4.	Etiquetas
Si se desea filtrar resultados según las etiquetas de los ítems, escriba una o varias etiquetas en este campo (separadas por comas) y pulse ENTER para aceptar. En la lista se mostrarán los ítems cuyas etiquetas sean iguales o contengan cualquiera de las introducidas en este campo.
5.	Descripción
Si se desea filtrar resultados según la descripción del ítem, escriba una cadena en este campo y pulse ENTER para aceptar. En la lista se mostrarán los ítems cuya descripción sea igual o contenga la cadena introducida en este campo.

  Pulse el botón “Limpiar filtros” en el momento que quiera limpiar los campos y reponer el estado inicial de los filtros.

Lista o Tabla de resultados
 
En la lista o tabla de resultados se muestran los ítems de biblioteca encontrados según los criterios de búsqueda en cada momento. Cada ítem aparece en una fila de la tabla.
1.	Las Columnas Nombre, Etiquetas y Descripción muestran los respectivos campos y pueden ser ordenables alfabéticamente. 
2.	Columna Ver contenido
 Pulsando en el icono “ojo”, abrimos una previsualización del contenido del ítem, así como el último usuario que lo editó:
 
  Pulsando de nuevo el icono ocultamos la previsualización.
3.	Columna Acciones
  
Contiene una serie de botones para realizar acciones sobre cada ítem de biblioteca: editar, editar contenido, copiar y eliminar.
Editar un ítem de la biblioteca
 Pulsando el botón Editar ítem de biblioteca de la columna Acciones, muestra un formulario donde el usuario podrá modificar cualquiera de los campos y guardarlo de nuevo. En esta acción se comprueba además que no haya ningún otro usuario que esté editando el ítem en ese mismo momento.
 

Editar el contenido de un ítem de biblioteca
  Pulsando el botón Editar contenido de la columna Acciones se accede directamente al editor de código, donde el usuario podrá modificar el código javascript o sql del ítem y salvarlo de nuevo. En esta acción se comprueba además que no haya ningún otro usuario que esté editando el contenido del ítem en ese mismo momento.
 

Copiar un ítem de biblioteca 
   Pulsando el botón Copiar ítem de biblioteca de la columna Acciones aparece un formulario para poder copiar este ítem, por ejemplo en otro dominio o proyecto, y se permite modificar ciertos campos como Nombre, Etiquetas o Descripción.
 

Eliminar un ítem de biblioteca
 Pulsando el botón Borrar ítem de biblioteca de la columna Acciones aparece un diálogo de confirmación para poder eliminar definitivamente este ítem.
 



 
====Usabilidad desde Modeling====

Acceso a Gestión de Bibliotecas desde Modeling
Cuando el usuario está modelando su diagrama y necesita acceder o consultar sus bibliotecas de código Javascript o Queries Sql, puede hacerlo de 2 maneras:
Manualmente
Abriendo una nueva pestaña de TAST en su navegador, donde abrirá la pantalla de Gestión de Bibliotecas. 
Automáticamente
 
Pulsando el botón “Abrir Gestión de Bibiotecas” desde la ventana de edición de código Javascript/Sql de Modeling, que automáticamente le lanzará la página Gestión de Bibliotecas en una nueva pestaña de su navegador. 
 
 
 

Nota: Recordar que la ventana de edición de código Javascript/Sql aparece en Modeling cuando se edita el código de mensajes tales como  executeJavascript, o dbGetQueryData, por ejemplo.
 
Guardar código Javascript/ Sql desde Modeling en una biblioteca
Cuando el usuario está modelando su diagrama y desea guardar el código javascript/query sql utilizado en un mensaje determinado, puede hacerlo de 2 maneras 
Manualmente
En la pantalla Gestión de Bibliotecas el usuario creará un nuevo ítem, y hará copiar el código de Modeling y a continuación pegar en el campo Contenido del nuevo ítem de biblioteca.
Automáticamente
 
Pulsando el botón “Nuevo ítem de biblioteca” desde la ventana de edición de código Javascript/Sql de Modeling, que automáticamente lanzará la página Gestión de Bibliotecas en una nueva pestaña de su navegador, y con el formulario de Crear un nuevo ítem de biblioteca abierto y con los campos Dominio, Proyecto, Tipo y Contenido ya rellenos.
 
 
 

 
Recuperar código Javascript/Sql desde una biblioteca para usarlo en Modeling

Cuando un usuario está modelando un diagrama y editando el código javascript o sql de un mensaje, y le gustaría traerse el código desde alguna de sus bibliotecas, este sería el procedimiento:  
1.	Abrir la pantalla de Gestión de Bibliotecas en una nueva pestaña de su navegador y  localizar el código deseado,  
2.	y simplemente hacer un copiar del código y un pegar del mismo en ventana de edición de código Javascript/Sql de Modeling.
TAST DokuWiki

User Tools

Site Tools

Page Tools
