Mejorando el código del test que suma dos números gracias al eclipse refactoring.

Por descargarpseint / hace 3 meses / 0 Comentarios ».

Hoy quiero hablarte de una técnica muy habitual al programar en java, sobre todo, en desarrolladores comprometidos con la excelencia y limpieza de código. Para ello voy a tomar como base una presentación muy didáctica donde nos hablan del eclipse refactoring como herramienta que nos ayuda a limpiar código de forma productiva. Por último, decirte que voy a aplicar al test que desarrollamos en el artículo anterior, una refactorización de código, paso a paso, para que puedas comprender mejor esta técnica de programación.

Aprendiendo un poco de limpieza de código y eclipse refactoring.

Eclipse refactoring from srcid

Ahora que ya te has hecho una idea de lo que vamos a hablar en el artículo te propongo un artículo muy práctico y detallado para que puedas comprender y experimentar con este concepto de la programación. Para ello te recuerdo cual era el código que desarrollamos en el artículo anterior y que nos va a servir como código de partida y sobre el cual vamos a ir haciendo cambios utilizando las herramientas que nos ofrece eclipse.

Código de partida a refactorizar.

package com.programarenjava.tuturiales.calculadora.implementaciones;

import org.junit.Assert;

import org.junit.Test;

import com.programarenjava.tutoriales.calculadora.implementaciones.CalculadoraDeLongs;

import com.programarenjava.tutoriales.calculadora.interfaces.Calculadora;

public class SumarDosEnterosTest {

        private Calculadora calculadora = new CalculadoraDeLongs();

        @Test

        public void testCeroMasCeroIgualACero(){

               Number sumar;

               boolean sumaIgualACero;

               sumar = calculadora.sumar(0, 0);

               sumaIgualACero = (sumar.intValue() == 0);

               Assert.assertTrue(sumaIgualACero);

        }

        @Test

        public void testQuinientosMasCeroIgualAQuinientos(){

               Number sumar;

               boolean sumarIgualAQuinientos;

               sumar = calculadora.sumar(500, 0);

               sumarIgualAQuinientos = (sumar.intValue() == 500);

               Assert.assertTrue(sumarIgualAQuinientos);

        }



        @Test

        public void testQuinientosMasSuInversoIgualACero(){

               Number sumar;

               boolean sumarIgualACero;

               sumar = calculadora.sumar(500, -500);

               sumarIgualACero = (sumar.intValue() == 0);

               Assert.assertTrue(sumarIgualACero);

        }



        @Test

        public void testQuinientosMasNumeroGrandeEsMayorQueCero(){

               Number sumar;

               boolean sumaMayorQueCero;

               sumar = calculadora.sumar(500, 2147483647);

               sumaMayorQueCero = (sumar.longValue()>0);

               Assert.assertTrue(sumaMayorQueCero);

        }

}

Convertir una variable local en un atributo privado.

Si observas el código de la clase que pretendemos refactorizar te habrás dado cuenta que cada test declara una variable local llamada sumar. La finalidad de dicha variable es la de almacenar el resultado de la suma. Declarar variables tiene un coste y destruirlas también. Ahora mismo cada vez que se lanzamos el suite de pruebas le estamos exigiendo a la JDK que realice las siguientes acciones:

  • Crear una variable local (al test que se está ejecutando en ese momento). Cuatro en total
  • Eliminar una variable local y nuevamente son cuatro cada vez que deseamos probar la suma de números.

La técnica que vamos a aplicar consiste precisamente en sustituir estas cuatros variables locales por un atributo privado asociado a la clase SumarDosEnterosTest. En eclipse los pasos que vas a tener que seguir son los siguientes:

  1. Sitúa el ratón sobre la variable sumar y teclea la combinación de teclas ALT+SHIFT+T(también puedes pulsar el botón derecho del ratón y escoger la opción Refactordentro del menú que te habrá aparecido).
  2. Ahora verás un menú vertical con todos los tipos de refactorización soportados por eclipse. Tienes que elegir Convert Local Variable to Field
  3. Te aparecerá un asistente para realizar la operación donde podrás especificar el nombre del atributo a generar y también podrás elegir el ámbito del mismo. Nos interesa que sea privado a la clase.
  4. Dispones del botón Previewdonde eclipse te muestra los cambios que va a realizar de forma automática por nosotros. Finalmente tendrás que darle al botón ok y a ya tendremos finalizada tu primer código refactorizado con eclipse (eclipse refactoring).

Las variables locales sumar de los otros métodos no vamos a poder convertirlos en atributos utilizando el eclipse refactoring que te acabo de explicar. La razón es que no queremos sustituir cuatros variables locales por cuatro propiedades privadas sino hacerlo solo por una.

Para ello tendrás que hacer manualmente lo siguiente. Situarte sobre cada variable sumar local y realizar el siguiente cambio

//Eliminamos la declaración

Number sumar;




//En todos los métodos quedándonos el código que te muestro a continuación




package com.programarenjava.tuturiales.calculadora.implementaciones;




import org.junit.Assert;

import org.junit.Test;




import com.programarenjava.tutoriales.calculadora.implementaciones.CalculadoraDeLongs;

import com.programarenjava.tutoriales.calculadora.interfaces.Calculadora;

public class SumarDosEnterosTest {

        private Calculadora calculadora = new CalculadoraDeLongs();

        private Number sumar;

        @Test

        public void testCeroMasCeroIgualACero(){

               boolean sumaIgualACero;

               sumar = calculadora.sumar(0, 0);

               sumaIgualACero = (sumar.intValue() == 0);

               Assert.assertTrue(sumaIgualACero);

        }

        @Test

        public void testQuinientosMasCeroIgualAQuinientos(){

               boolean sumarIgualAQuinientos;

               sumar = calculadora.sumar(500, 0);

               sumarIgualAQuinientos = (sumar.intValue() == 500);

               Assert.assertTrue(sumarIgualAQuinientos);

        }

        @Test

        public void testQuinientosMasSuInversoIgualACero(){

               boolean sumarIgualACero;

               sumar = calculadora.sumar(500, -500);

               sumarIgualACero = (sumar.intValue() == 0);

               Assert.assertTrue(sumarIgualACero);

        }

        @Test

        public void testQuinientosMasNumeroGrandeEsMayorQueCero(){

               boolean sumaMayorQueCero;




               sumar = calculadora.sumar(500, 2147483647);




               sumaMayorQueCero = (sumar.longValue()>0);




               Assert.assertTrue(sumaMayorQueCero);

        }




}

Cambiar el nombre de una variable.

Lo siguiente que vamos a hacer es una unificación de nombres para la variable booleana encargada de guardar la validación de la prueba en cada uno de los test. Eclipse nos proporciona otro rafactoring que nos facilita el trabajo y que te voy a describir a continuación.

Lo primero que tienes que hacer es situarte sobre la variable sumaIgualACero. Una vez lo hayas hecho entonces utilizas el siguiente atajo del teclado ALT+SHIFT+R (Con el ratón botón derecho y después realizas la siguiente navegación por el menú vertical Refactor->Rename).

En ese momento eclipse selecciona con un rectángulo la variable que deseamos renombrar y todas las referencias a ella. Si eliminas el nombre y lo sustituyes por condicionDeExitoDelTest verás que se está actualizando el identificador en todos los lugares del código donde aparece. En el ejemplo al que estamos aplicando eclipse refactoring sería en tres lugares.

En el ejemplo ya has podido apreciar la diferencia que existe entre utilizar este rafactoring y hacerlo a mano. Si ya has programado antes en java sin utilizar eclipse refactoring o vienes de otros lenguajes sabrás lo conflictivo que a veces resulta cambiar el nombre a una variable que ya está siendo referenciada en otras partes del código.

Esta misma acción la vamos a repetir para las variables locales sumaIgualAQuinientossumaIgualACero y sumaMayorQueCero.

Si ahora aplicamos el cambio de variable local a propiedad de la clase obtendremos un código como el que te muestro a continuación.

import org.junit.Assert;

import org.junit.Test;

import com.programarenjava.tutoriales.calculadora.implementaciones.CalculadoraDeLongs;

import com.programarenjava.tutoriales.calculadora.interfaces.Calculadora;




public class SumarDosEnterosTest {




        private Calculadora calculadora = new CalculadoraDeLongs();

        private Number sumar;

        private boolean condicionDeExitoDelTest;




        @Test

        public void testCeroMasCeroIgualACero(){

               sumar = calculadora.sumar(0, 0);




               condicionDeExitoDelTest = (sumar.intValue() == 0);




               Assert.assertTrue(condicionDeExitoDelTest);

        }




        @Test

        public void testQuinientosMasCeroIgualAQuinientos(){

               sumar = calculadora.sumar(500, 0);




               condicionDeExitoDelTest = (sumar.intValue() == 500);




               Assert.assertTrue(condicionDeExitoDelTest);

        }




        @Test

        public void testQuinientosMasSuInversoIgualACero(){

               sumar = calculadora.sumar(500, -500);




               condicionDeExitoDelTest = (sumar.intValue() == 0);




               Assert.assertTrue(condicionDeExitoDelTest);

        }




        @Test

        public void testQuinientosMasNumeroGrandeEsMayorQueCero(){

               sumar = calculadora.sumar(500, 2147483647);




               condicionDeExitoDelTest = (sumar.longValue()>0);




               Assert.assertTrue(condicionDeExitoDelTest);

        }




}

Una vez llegados aquí ya tenemos el código mas limpio y simplificado. No son muchas líneas programadas y por ello no habrás notado una gran diferencia, sin embargo, los programas reales terminan teniendo miles de líneas en cada clase y aplicar técnicas de refactorización de código son fundamentales para frenar la complejidad del mismo.

Los programas evolucionan lo que supone un crecimiento de código que puede llegar a ser inmanejable. Ser precavido es un muy buen hábito para un programador y por ello, siempre que puedas, tienes que intentar revisar el código que estás desarrollando con la intención de mejorarlo a través de simplificaciones y detección de trozos de código reutilizables.

Ahora que ya sabes refactorizar código y dispones del conocimiento suficiente para implementar la operación sumar para la calculadora te propongo que intentes programar las operaciones restar, multiplicar y dividir. Para ello dispones de los operadores -,* y /.

En el próximo artículo te presentaré la clase java.lang.Math, la cual nos va a ayudar a implementar las operaciones potencia y raizCuadrada de nuestra Calculadora. Nuevamente definiremos test unitarios que nos permitan validar el comportamiento de estas nuevas operaciones. Por último, reflexionaremos sobre la solución que hemos implementado y te presentaré una nueva versión de la calculadora que hará uso de características del lenguaje que ya hemos visto como la herencia e introduciremos el concepto de clase plantilla, también conocido como genéricos dentro de java.

Ver: Cómo aprender a programar

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *