Pruebas a Polivirtual y Proxy

Mapa, prueba de software

Pruebas de software

Definición de la conferencista de Ingeniería de Sistemas

La rama de la ingeniería que facilita la implementación de una correcta combinación de herramientas de software y hardware que permitan apoyar:

➥ La estrategia de los países

➥ La estrategia de negocio de las compañías

➥ La felicidad y facilidad en la vida de las personas

Algo de historia en Colombia de las pruebas de Software– Percepciones cómunes

● Descrédito de las pruebas de software

➢ Las pruebas no están funcionando, simplemente es un

requerimiento más del método

➥ Falta de implementación de métodos formales

➥ Falta de personas entrenadas

● “Las Pruebas son responsabilidad del usuario”

➢ Las pruebas de aceptación se convirtieron en pruebas de

sistema

➢ No es su trabajo, costo de oportunidad

➢ Los Usuarios no están entrenados para tal efecto, complejidad técnica, ad-hoc testing

Generalidades

● Definición de Software Testing (Pruebas de Software)

 Proceso realizado concurrentemente a través de las diferentes etapas de desarrollo de software que utiliza y mantiene el testware y cuyo objetivo es apoyar la disminución del riesgo de aparición de fallas y faltas en operación.

El proceso de pruebas es parte del ciclo de desarrollo de software, como uno de los tantos procesos que

intervienen en la creación de un producto.

Niveles de Pruebas: Unitarias, Integración,Sistema y Aceptación

● Cada etapa  de desarrollo genera artefactos a los cuales se les debe aplicar (en ciclos de vida clásicos):

➢ Pruebas Unitarias: Realizadas por el creador del artefacto

➢ Pruebas Integración: Realizadas por el creador del artefacto

➢ Pruebas de Sistema: Realizadas por el equipo de pruebas

➢ Prueba de Aceptación – Usuario: Se realizan al final de las anteriores, cuando los artefactos están listos.

● Existe estrategia para cada una de ellas

● Generalmente la literatura sobre pruebas, está dirigida a pruebas funcionales en construcción.

Qué se necesita para implementar pruebas

● Qué tipos de pruebas se van a exigir

➢ Depende de mi modelo de desarrollo (Clásico, Ágil?)

➢ Unitarias, integración, de sistemas o aceptación?

➢ Dependiendo, se debe establecer e implantar procesos y

métodos. Algunos ejemplos para pruebas de sistema

➥ STEP,

➥ Requierments Based Testing,

➥ TMAP (Structured Test Management Approach)

Tipos de prueba- Pruebas de Sistema

Sistema

Una propuesta de un método de pruebas de sistema (para un ciclo de vida clásico)

Conformación básica para proyecto con pruebas

Finalmente

● Cada tipo de prueba implica:

➢ Enfoques distintos

➢ Perfiles de personas distintos

➢ Diferentes Estrategias para atacar la prueba

➢ Herramientas distintas

➢ Conocimientos distintos

Aunque se presentan altos niveles de satisfacción,  las estadísticas Choucair muestran una efectividad de más o menos un 97%, en defectos de impacto severo o alto. NO SON LA SALVACION.

No es una moda, es un proceso de un ciclo de vida de desarrollo de software

Conclusiones

Las prueba son un proceso de ciclo de vida de desarrollo de software que deben ser aplicadas en cada ciclo de vida, cada vez que se encuentre un defecto se debe corregir inmediatamente. También poner a las personas adecuadas para realizar las pruebas y conocer el tipo que son más conveniente a nuestro software.

Triángulo Isósceles

Triángulo Isósceles

Código fuente

public class TrianguloI {
    double lado1;
double lado2;

 
    public TrianguloI(double dato1, double dato2){
    lado1 = dato1;
lado2 = dato2;
    }
    public double area(){
        return ((lado1 * lado2) / 2);
    }
 
    public double perimetro(){
        return ((lado1 * 2) + lado2);
    }
 
    public double obtenerLado1(){
        return lado1;
    }
 
    public void modificarLado1(double dato1){
     lado1=dato1;
    }
public double obtenerLado2(){
        return lado2;
    }
 
    public void modificarLado2(double dato2){
        lado2=dato2;
    }
 
}

Código de la prueba

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.*;
import TrianguloI;
/**
 *
 * @author Alumnos
 */
public class TrianguloITest {
 
    static TrianguloI TrianguloI;
 
    public TrianguloITest() {
    }
 
    @BeforeClass
    public static void setUpClass() {
      TrianguloI = new TrianguloI(2.5,10.0);
    }
 
    @AfterClass
    public static void tearDownClass() {
    }
 
    @Before
    public void setUp() {
    }
 
    @After
    public void tearDown() {
    }
    /**
     * Test of area method, of class TrianguloI.
     */
    @Test
    public void areaTest(){
        assertEquals(TrianguloI.area(),30,0);
    }
    @Test
    public void perimetroTest(){
        assertEquals(TrianguloI.perimetro(),25,0);
    }
    @Test
    public void obtenerLadosTest(){
        assertEquals(TrianguloI.obtenerLado1(),2,5);
        assertEquals(TrianguloI.obtenerLado2(),10,0);
    }
 
    @Test
    public void modificarLadosTest(){
        TrianguloI.modificarLado1(3.0);
        assertEquals(TrianguloI.obtenerLado1(),3,0);
    }
    @Test
    public void nuevoTest(){
       System.out.println(TrianguloI.obtenerLado1());
    }
} 

Triángulo Escaleno

Triángulo Escaleno

Código fuente

public class TrianguloEscaleno {
    double lado1;
double lado2;
double lado3;

 
    public TrianguloEscaleno(double dato1, double dato2, double dato3){
    lado1 = dato1;
lado2 = dato2;
lado3 = dato3;
    }
    public double area(){
        return ((lado1 * lado2) / 2);
    }
 
    public double perimetro(){
        return (lado1 + lado2 + lado3);
    }
 
    public double obtenerLado1(){
        return lado1;
    }
 
    public void modificarLado1(double dato1){
     lado1=dato1;
    }
public double obtenerLado2(){
        return lado2;
    }
 
    public void modificarLado2(double dato2){
        lado2=dato2;
    }
 
public double obtenerLado2(){
        return lado2;
    }
 
    public void modificarLado3(double dato3){
        lado3=dato3;
    }
}

Código de la prueba

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.*;
import TrianguloEscaleno;
/**
 *
 * @author Alumnos
 */
public class TrianguloEscalenoTest {
 
    static TrianguloEscaleno TrianguloEscaleno;
 
    public TrianguloEscalenoTest() {
    }
 
    @BeforeClass
    public static void setUpClass() {
      TrianguloEscaleno = new TrianguloEscaleno(2.5,10.0);
    }
 
    @AfterClass
    public static void tearDownClass() {
    }
 
    @Before
    public void setUp() {
    }
 
    @After
    public void tearDown() {
    }
    /**
     * Test of area method, of class TrianguloEscaleno.
     */
    @Test
    public void areaTest(){
        assertEquals(TrianguloEscaleno.area(),30,0);
    }
    @Test
    public void perimetroTest(){
        assertEquals(TrianguloEscaleno.perimetro(),25,0);
    }
    @Test
    public void obtenerLadosTest(){
        assertEquals(TrianguloEscaleno.obtenerLado1(),2,5);
        assertEquals(TrianguloEscaleno.obtenerLado2(),10,0);
    }
 
    @Test
    public void modificarLadosTest(){
        TrianguloEscaleno.modificarLado1(3.0);
        assertEquals(TrianguloEscaleno.obtenerLado1(),3,0);
    }
    @Test
    public void nuevoTest(){
       System.out.println(TrianguloEscaleno.obtenerLado1());
    }
}

Triángulo Equilátero

Triángulo Equilátero

Código

public class TrianguloEquilatero {
    double lado1;

    public TrianguloEquilatero(double dato1){
    lado1 = dato1;
    }
    public double area(){
        return ((lado1 * lado1) / 2);
    }
 
    public double perimetro(){
        return (lado1 * 3);
    }
 
    public double obtenerLado1(){
        return lado1;
    }
 
    public void modificarLado1(double dato1){
     lado1=dato1;
    }
 
}

Código de la prueba

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.*;
import TrianguloEquilatero;
/**
 *
 * @author Alumnos
 */
public class TrianguloEquilateroTest {
 
    static TrianguloEquilatero TrianguloEquilatero;
 
    public TrianguloEquilateroTest() {
    }
 
    @BeforeClass
    public static void setUpClass() {
      TrianguloEquilatero = new TrianguloEquilatero(2.5,10.0);
    }
 
    @AfterClass
    public static void tearDownClass() {
    }
 
    @Before
    public void setUp() {
    }
 
    @After
    public void tearDown() {
    }
    /**
     * Test of area method, of class TrianguloEquilatero.
     */
    @Test
    public void areaTest(){
        assertEquals(TrianguloEquilatero.area(),30,0);
    }
    @Test
    public void perimetroTest(){
        assertEquals(TrianguloEquilatero.perimetro(),25,0);
    }
    @Test
    public void obtenerLadosTest(){
        assertEquals(TrianguloEquilatero.obtenerLado1(),2,5);
        assertEquals(TrianguloEquilatero.obtenerLado2(),10,0);
    }
 
    @Test
    public void modificarLadosTest(){
        TrianguloEquilatero.modificarLado1(3.0);
        assertEquals(TrianguloEquilatero.obtenerLado1(),3,0);
    }
    @Test
    public void nuevoTest(){
       System.out.println(TrianguloEquilatero.obtenerLado1());
    }
} 

Círculo

Círculo

Código fuente:

public class Circulo {
    double lado1;

 
    public Circulo(double dato1){
    lado1 = dato1;

    }
    public double area(){
        return ((lado1 * lado1) * 3.1416);
    }
 
    public double perimetro(){
        return (lado1 * 3.1416);
    }
 
    public double obtenerLado1(){
        return lado1;
    }
 
    public void modificarLado1(double dato1){
     lado1=dato1;
    }
 
}

Código de la prueba

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.*;
import Círculo;
/**
 *
 * @author Alumnos

public class CirculoTest {
   
    static Circulo circulo;
   
    public CirculoTest() {
    }
   
   @BeforeClass
    public static void setUpClass() throws Exception {
        circulo = new Circulo(15.0);
    }
   
    @AfterClass
    public static void tearDownClass() throws Exception {
    }
   
    @Before
    public void setUp() {
    }
   
    @After
    public void tearDown() {
    }

   
    @Test
    public void areaTest(){
        assertEquals(circulo.area(),709.11,0);
    }
    @Test
    public void perimetroTest(){
    assertEquals(circulo.perimetro(),47.274,0);
    }
    @Test
    public void obtenerLadoTest(){
        assertEquals(circulo.obtenerRadio(),15,0);
    }
    @Test
    public void modificarLados
            Test(){
        circulo.modificarRadio(4);
        assertEquals(circulo.obtenerRadio(),4,0);
    }
    @Test
    public void nuevoTest(){
        System.out.println(circulo.obtenerRadio());
    }
   
}

Cuadrado

Cuadrado

Código

public class Cuadrado {
    double lado1;

 
    public Cuadrado(double dato1){
    lado1 = dato1;

    }
    public double area(){
        return lado1 * lado1;
    }
 
    public double perimetro(){
        return (lado1*4);
    }
 
    public double obtenerLado1(){
        return lado1;
    }
 
    public void modificarLado1(double dato1){
     lado1=dato1;
    }
 
}

Código del  la prueba

package cuadrado;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.*;
import cuadrado.Cuadrado;
/**
 *
 * @author Alumnos
 */
public class CuadradoTest {
 
    static Cuadrado Cuadrado;
 
    public CuadradoTest() {
    }
 
    @BeforeClass
    public static void setUpClass() {
      Cuadrado = new Cuadrado(2.5,10.0);
    }
 
    @AfterClass
    public static void tearDownClass() {
    }
 
    @Before
    public void setUp() {
    }
 
    @After
    public void tearDown() {
    }
    /**
     * Test of area method, of class Cuadrado.
     */

    @Test
    public void areaTest(){
        assertEquals(Cuadrado.area(),30,0);
    }
    @Test
    public void perimetroTest(){
        assertEquals(Cuadrado.perimetro(),25,0);
    }
    @Test
    public void obtenerLadosTest(){
        assertEquals(Cuadrado.obtenerLado1(),2,5);
        assertEquals(Cuadrado.obtenerLado2(),10,0);
    }
 
    @Test
    public void modificarLadosTest(){
        Cuadrado.modificarLado1(3.0);
        assertEquals(Cuadrado.obtenerLado1(),3,0);
    }
    @Test
    public void nuevoTest(){
       System.out.println(Cuadrado.obtenerLado1());
    }
}

Rectàngulo

Rectángulo

Código

package rectangulo;

public class Rectangulo {

    double lado1; 

    double lado2;

    

    public Rectangulo(double dato1, double dato2){ 

    lado1 = dato1; 

    lado2 = dato2;

    }

    public double area(){ 

        return lado1 * lado2; 

    } 

    

    public double perimetro(){ 

        return ((lado1*2) + (lado2*2)); 

    } 

    

    public double obtenerLado1(){ 

        return lado1; 

    } 

    

    public void modificarLado1(double dato1){ 

     lado1=dato1; 

    } 

    

    public double obtenerLado2(){ 

        return lado2; 

    } 

    

    public void modificarLado2(double dato2){ 

        lado2=dato2; 

    }

}

 Código del  la prueba

package rectangulo;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.*;
import rectangulo.Rectangulo;
/**
 *
 * @author Alumnos
 */
public class RectanguloTest {
 
    static Rectangulo rectangulo;
 
    public RectanguloTest() {
    }
 
    @BeforeClass
    public static void setUpClass() {
      rectangulo = new Rectangulo(2.5,10.0);
    }
 
    @AfterClass
    public static void tearDownClass() {
    }
 
    @Before
    public void setUp() {
    }
 
    @After
    public void tearDown() {
    }
    /**
     * Test of area method, of class Rectangulo.
     */

    @Test
    public void areaTest(){
        assertEquals(rectangulo.area(),30,0);
    }
    @Test
    public void perimetroTest(){
        assertEquals(rectangulo.perimetro(),25,0);
    }
    @Test
    public void obtenerLadosTest(){
        assertEquals(rectangulo.obtenerLado1(),2,5);
        assertEquals(rectangulo.obtenerLado2(),10,0);
    }
 
    @Test
    public void modificarLadosTest(){
        rectangulo.modificarLado1(3.0);
        assertEquals(rectangulo.obtenerLado1(),3,0);
    }
    @Test
    public void nuevoTest(){
       System.out.println(rectangulo.obtenerLado1());
    }
}

Impresión de pantalla

Casos de prueba

EVALUACION DE PRUEBAS

INTEC

Evaluación de pruebas: Debemos tomar en cuenta que cuando una prueba ya se realizó –ya se obtuvieron resultados– eso no implica que ya concluyó, el ciclo de vida de pruebas se concluye con la evaluación, en donde se especifica la comparación entre los resultados esperados y los obtenidos con la prueba determinando si ésta fue o no exitosa.

Jmeter: Los reportes generados con JMeter nos proporcionan información que podemos agrupar en tablas o cuadros comparativos o en un resumen respecto a lo que arrojaron las pruebas efectuadas, indicando cuál fue el objetivo.

JMeter proporciona un resumen de los reportes que se generaron. Éstos pueden ser de tres tipo:

•       Un resumen de las pruebas realizadas.

•       Una estadística de cada llamada.

•       Todos los componentes que se llamaron.

Para crear los reportes debes únicamente hacer clic en “add, listener, summaryreport” para el primer tipo, o cambiando “summaryreport” por “Ver Resultados en Árbol” para el segundo tipo, o Ver Árbol de Resultados, como se puede observar en la imagen.

Metricas: Se debe tener métricas de calidad establecidas para calcular las cifras y hacer la comparación con los resultados arrojados por las pruebas elaboradas con la herramienta.

Algunas métricas importantes son:

•       Líneas de código. Número de líneas de código del proyecto. Esta métrica sólo tiene en cuenta las líneas que corresponden al código Java, no incluye comentarios, líneas en blanco o algo similar.

•       Clases. Número de clases del proyecto, incluidas clases internas, interfaces, enumeraciones y anotaciones.

•       Métodos. Número de métodos, sin incluir get o set. Los constructores se cuentan entre los métodos.

•       API público documentado. El número de clases, métodos y atributos públicos con un bloque de Javadoc.

Algunas métricas importantes son:

•       Complejidad ciclomática. Se suma los 'if', 'for', 'while' y sentencias de control; a cada una se le da el peso de “1”. También cada método tiene un valor mínimo de “1”en el cálculo de la complejidad, excepto los get y los set que no son considerados métodos. Cada una de las siguientes sentencias y palabras clave incrementan en “1” la complejidad:

•       if

•       for

•       while

•       case

•       catch

•       throw  

•       return (si no es la última sentencia de un método)

•       &&

•       ||

•       ?

Otros ejemplos de métricas a comparar son:

•       Tamaño= n + a. Donde “n” es el número de módulos y “a” es el número de líneas de control; esto es, si se tienen 17 módulos y 18 líneas de control entre éstas, el resultado es: tamaño = 17+18 = 35.

•       Profundidad. Es el camino más largo desde el nodo raíz a un nodo hoja (siguiendo una integración descendente, primero en profundidad).

•       Amplitud. Es el número máximo de nodos de cualquier nivel de la arquitectura. Para el ejemplo de la imagen de módulos, la amplitud es de 3.

CICLO DE PRUEBAS

TECNOLED

El ciclo de vida de la automatización comienza en la etapa de diseño del modelo de desarrollo en cascada del software, para plantear en principio los casos de prueba y elaborarlos en la herramienta correspondiente, concluyendo en la etapa de mantenimiento del software, de acuerdo a esta arquitectura, teniendo en consideración los requerimientos con su respectiva gestión.  

En cada desarrollo de software tenemos un ciclo de pruebas y varios ciclos de vida de las pruebas, lo cual, normalmente, está determinado por el modelo de desarrollo del software. En cada uno de estos ciclos se tiene  que planear, diseñar, ejecutar las pruebas, obtener resultados y evaluar estos resultados.

Requerimientos de prueba

Los requerimientos de prueba del software son todos los recursos que necesitamos para ejecutar una prueba. Para ello establecemos un ambiente de pruebas, en el cual se considera: software, hardware, configuración, personal y documentos.

Para una prueba es necesario tenerlos requerimientos del sistema, sobre todo los funcionales que son indispensables para diseñar los casos de prueba.

De los requerimientos funcionales se desprende uno de los documentos base para el buen desarrollo del sistema: el diagrama UML de Casos de uso, con su respectiva especificación, donde podemos extraer las precondiciones para establecer nuestras consideraciones para los valores de entrada del caso de prueba.

Las pos condiciones que nos indican los resultados que se deben esperar, los flujos básicos y alterno, de donde obtenemos nuestros escenarios para los guiones de prueba.

Para manipular los escenarios podemos utilizar, en JMeter, el “Controlador lógico”. Éste controla el comportamiento de la prueba tomando decisiones en función de situaciones, por ejemplo, si se lleva a cabo una petición HTTP con base en una condición. Este tipo de controlador trae valores por default. 

Administraciòn de requerimientos

Para gestionar apropiadamente los requerimientos es necesario controlar y da un seguimiento a las pruebas. Con JMeter se pueden obtener distintos tipos de informes que de alguna manera nos permiten administrar lo que se está llevando a cabo.

En los informes que configuremos evaluaremos los resultados porque allí estarán reflejados, listos para ser analizados.