Skip to main content

Testing (Progresivo)

Testing (Progresivo)
Realmente una parte fundamental del desarrollo de aplicaciones la implementaciòn de pruebas, en el mundo Java se cuentan con muchas herramientas. (TDD, BDD, ATDD).
Entre algunos :

  • JUnit
  • Arquillian  
  • Selenium
  • JCucumber, 
  • Mockito,
  • EasyMock

Muchas veces creamos un entorno embebido para ejecutar pruebas (Arquillian), Antonio Gongalves
escribio un blog : Java EE vs Spring Testing.
Donde explicaba la complejidad de hacer los test y la viabilidad de los mismos.

Conocemos la situación actual con EJB el movimiento de Java EE a EE4J,  la era de microservicios, muchas implementaciones han cambiado, una forma nueva de desarrollar aplicaciones y consumir data. (Rest-Ful, JAX-RS, bases de datos NoSQL).


Que ocurriría si alteramos la forma de hacer los test en un entorno JavaEE que usa EJB:
  • Hacer los test en  entornos de ejecución  y no en entornos embebidos.(Tendríamos un entorno  real para las pruebas).
  • Hacer test progresivos, tendríamos un esquema de adaptación mas ágil.
  • Generar las interfaces en base a los test(Tal vez ayudaría al equipo a entender la vista de una pagina que no paso un test), seria componer interfaces en base a testing.



Componentes:
  • Proyecto Java EE
  • Proyecto EJB que contiente los Entity y Repository
  • PayaraMicro (Podria implementar con otro)
  • Framework de Test




Modelo:

  • Utilizamos dos clases
  • UnitTest : Para reporte del test
  • UnitView: Para generar interfaces desde los test.

Ejemplos:

Test Simple

 @Test
    public String save() {
        try {

//Mock
            Color color = new Color();
            color.setActivo("si");
            color.setAutoincrementable(15);
            color.setIdcolor("rojo");
            List<UserInfo> list = new ArrayList<>();
            color.setUserInfo(list);
            Boolean expResult = true;
            
           unitTest.assertEquals("save", true, colorRepository.save(color));

         
        } catch (Exception e) {
            System.out.println("save() " + e.getLocalizedMessage());
        }

        return "";
    }

Reportes

Ejemplo de una ejecuciòn



Test diseñando una interface.
El equipo de Testing, crea el Test y genera una interfaz de como seria la aplicaciòn final.

 @Test
    public String save() {
        try {
//            unitView.message("Testeando save()");
//Mock
            Color color = new Color();
            color.setActivo("si");
            color.setAutoincrementable(15);
            color.setIdcolor("rojo");
            List<UserInfo> list = new ArrayList<>();
            color.setUserInfo(list);
            Boolean expResult = true;
            Boolean save = unitTest.assertEquals("save", true, colorRepository.save(color));

            /*
            Dibuja la interfaz
             */
            unitView.form();
            unitView.formTitle("Registros de colores");
            unitView.panel();

            unitView.panelAddInputText(Arrays.asList(new InputText("idcolor", color.getIdcolor()),
                    new InputText("activo", color.getActivo())));

           
            unitView.panelClose();
            unitView.buttonGreen("Save");
            unitView.formClose();
            if (save) {
                unitView.message("se guardo exitosamente");
            } else {
                unitView.error("No se pudo guardar");
            }

        } catch (Exception e) {
            System.out.println("save() " + e.getLocalizedMessage());
        }

        return "";
    }

Ejecución:
Genera el resultado del Test y muestra la interface.





Tabla:
 @Test
    public String findAll() {
            List<Color> colorList = colorRepository.findAll();
                unitTest.assertEquals("findAll", 1, colorList.size());
                unitView.formTitle("findAll()");
                unitView.tableHeader(Arrays.asList(new RowView("idcolor"), new RowView("activo")));
                colorRepository.findAll().forEach((c) -> {
                    unitView.tableCol(Arrays.asList(new ColView(c.getIdcolor()), new ColView(c.getActivo())));
                });
                unitView.tableClose();
         
         
   
        return "";
    }

Genera

Comments

Popular posts from this blog

Tutorial básico de aplicaciones Web con NetBeans parte 1

NetBeans ofrece un excelente soporte para el desarrollo de aplicaciones Web, en esta ocasión lo haremos utilizando el Framework Java Server Faces 2.0. En el Menu Seleccionamos Nuevo->Proyecto y luego en Categorias Java Web y en tipo de Proyectos Web  Application indicamos el nombre del proyecto Seleccinamos el servidor Web, usamos GlassFish ya que este soporta EJB3.0 y JSF 2.0 Framework Java Server Faces El IDE genera el esquelto del proyecto Web Pages   almacenamos las paginas .html, xhtml, jsf, los archivos de recursos, los scripts .js, imagenes Source Packages    Son las clases Java  Test Packages    Son las clases que usamos para los Test Libraries     Tenemos las bibliotecas de Java y GlassFish necesarias para ejecutar la aplicación Web. Test Libraries     Están las bibliotecas usadas para los test  Configuration Files    Archivos de configuración de la aplicación. Ejecutamos la...

Incrementar Memoria NetBeans

Algunas veces necesitamos incrementar la memoria para un mejor rendimiento. http://www.netbeans.org/community/releases/55/uml-download.html Este es un ejemplo para UML. Descripción en ingles. Increasing Memory Settings (applicable to all builds) The default memory settings for NetBeans should be increased for UML projects. If you have the available memory, Locate your NetBeans installation directory ($install_dir). This can be found by starting up NetBeans and selecting Help -> About then select the Detail tab. Edit the $install_dir/etc/netbeans.conf file. Find the line defining netbeans_default_options . Increase the maximum memory attribute to -J-Xmx512m. If you experience heap overflows while working with larger files, you should increase this value further.

Test con JUnit

El viernes dicte un taller en el que conversábamos sobre Tecnologías Java y luego desarrollamos una aplicación muy básica para demostrar como utilizar JUnit con NetBeans. Pasos: 1. Crear un proyecto Desktop con NetBeans 2. Crear una clase llamada Operaciones 3. Diseñados un formulario y agregramos componentes de manera que quede similar a la figura Código de los botones try { double a = Double.parseDouble(jTextField1.getText()); double b = Double.parseDouble(jTextField2.getText()); Operaciones operaciones = new Operaciones(); double r = operaciones.Sumar(a, b); jTextField3.setText(String.valueOf(r)); } catch (Exception ex) { JOptionPane.showMessageDialog(this, ex.getMessage().toString()); } 4. Creamos los test Seleccionamos las clases En el menu Herramientas,seleccionamos Crear pruebas JUnit Seleccionamos la versión de JUnit En la ventana siguiente seleccionamos los parámetros para nuestras pruebas . Le quitamos la selección a Probar Inicializador y Probar Finalizador NetBeans crea las...