[TALLER] Demostración de implementación de proyectos individuales

Demostración de mi programa funcionando.

Presentaciones finales de proyectos individuales

Presentación final de la clase.

[TALLER] Implementación y aplicación de pruebas unitarias

En esta entrada explicare los pasos para realizar mi prueba.

Primero que nada quería decir que quería hacer esta prueba a modo de ejemplo, probando la funcionalidad del envió de notas a la base de datos, según yo si funcionaba, pero a la hora de ejecutar estos tests me doy cuenta que no funcionaba, afortunadamente lo solucione.

Para los test utilizare mi clase Notas:

package Organidatabase;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.sql.SQLException;
import java.util.Scanner;

public class Notas extends Database{
 String nota;
 String para;
 
 InputStreamReader isr = new InputStreamReader(System.in);
 BufferedReader br = new BufferedReader (isr);
  
  public Notas () {
     }
  
  public String note() throws IOException{
    System.out.println("Escriba su nota: ");
        nota=br.readLine();
        nota = nota.replace(' ','_');
        System.out.println(nota);
        return nota;
  }
  
  public String to(){
   System.out.println("Para: ");
      Scanner a = new Scanner(System.in);
      para=a.next();
      return para;
  }

  public String get_all(String note, String to, String from){
  try{
   stmt = ct.prepareStatement("INSERT INTO notes (idAlumnos, note, idTo) VALUES (?,?,?)");
   stmt.setString(1,from);
   stmt.setString(2, note);
   stmt.setString(3, to);
   stmt.executeUpdate();
   stmt.close();
   String all = "Se envió exitosamente:\n"+note+"\nPara:\n"+to;
   return all;
  }catch(SQLException i){
   System.out.println("Ocurrio un error.");
   return null;
  }
 }
}

Explico brevemente, lo que hace es tomar dos strings, e insertarlos dentro de la base de datos, el string note() genera la nota y transforma los espacios en blanco en guiones, el string to() solo recibe una cadena de texto equivalente a la matricula de quien se envia. Por ultimo el método get_all() inserta dentro de la base de datos los strings y devuelve un objeto string para asegurar que se envio la nota.

En cuanto a mi test:

package Organidatabase;

import java.io.IOException;

import junit.framework.TestCase;

public class TestNotas extends TestCase {
 
 private String s;
 
  public TestNotas( String nombre ) {
    super( nombre );
  }

  public static void main( String args[] ) {
    junit.textui.TestRunner.run( TestNotas.class );
  }
  
  public void setUp() {
   Notas n = new Notas();
   try {
  s=n.get_all(n.note(), n.to(), "1441708");
 } catch (IOException e) {
  // TODO Auto-generated catch block
  e.printStackTrace();
 }
  }

  public void testEnviaNota() {
    assertNotNull(s);
  }


}

El test asegura el envío o marca el error al no poder enviarlo. En el setUp()
 se declara un objeto del tipo Notas, el string s recibe el valor de get_all().

En teoría todo está bien, una vez que s reciba el string dejara de ser null y el testEnviarNota() basicamente comprueba de que el string s no sea nulo.

Ok, pasare a ejecutar el test:

En la consola marcó un error.

JUnit marca una falla.

La falla se debe a que como el string s es precisamente un string, yo en el ejemplo puse a y b como entradas, y aunque teoricamente debería ser valido ya que dentro de un string  puede ir tansolo un caractér y a final de cuentas get_all() sevuelve un string completo donde a y b se juntan, hay una falla con el ImputStreamReader y el BufferReader, solo aceptan strings y lanzan una excepción del tipo IOexception, esto corta el programa y sucede el fallo.

Lo corro de nuevo, esta vez con parametros adecuados:

Y JUnit:

Parece que todo salió bien.

Ahora, el verdadero problema que tuve con mi clase fue, según yo, que mi base de datos no aceptaba una entrada de strings con espacios, tenía que cambiar el Scanner por el ImputStreamReader, o de lo contrario obtenía una linda excepción.

De esta manera, podia utilizar la función replace para cambiar los espacios por guiones y de la misma manera al recibir la nota hace el proceso contario.

JUnit me ayudó mas que nada a detectar dónde fallaba, de ahí me base para encontara el verdadero problema que generaba el fallo.

Diseño de pruebas unitarias

En esta entrada explicaré lo que son las pruebas unitarias y las herramientas que utilizaré.

 

Primero que nada, las pruebas unitarias son una herramienta muy importante para el personal de pruebas pero, sobre todo, para los desarrolladores. Nos sirven para detectar errores dentro de los módulos de código, asegura el correcto funcionamiento de cada uno de estos por separado.

 

Una prueba unitaria es buena cuando:

• Es automatizable: donde no se requiere una intervención manual.
• Cubren la mayor cantidad de código.
• Repetibles o reutilizables: pruebas que se utilizan más de una vez.
• Independientes: la ejecución de una prueba no afecta la ejecución de otra.
• Profesionales: las pruebas deben ser consideradas igual que el código, con la misma profesionalidad, documentación, etc.

 Algunas ventajas de utilizar pruebas unitarias son:

• Fomentan el cambio: facilitan el cambio de código para mejorarlo asegurando que los cambios no introduzcan errores.
• Sirven como documentación.
• Los errores están más acotados y son más fáciles de localizar: dado que tenemos pruebas unitarias que pueden desenmascararlos.

Proceso de desarrollo de pruebas unitarias.

Esta metodología ha levantado bastante polémica dentro del mundo de la ingeniería del software en cuanto a los beneficios que proporciona y los límites que sobrepasa más allá de la programación tradicional. Es por esto que hay una gran diversidad de opiniones acerca de las desventajas que puede conllevar el uso de este sistema de programación.

• En primer lugar el hecho de escribir todos los requerimientos al inicio podría provocar el abuso en la cantidad de los elegidos con el fin de evitar dejar en el olvido alguno.
• A veces sucede que las propias pruebas unitarias resultan más costosas, desde el punto de vista de la implementación, que la propia implementación del software que se pretende crear, ya que a veces puede resultar más dificultoso encontrar los posibles fallos en los que puede caer la aplicación que la codificación de la misma.
• Si los casos de prueba que se crean son incorrectos entonces se implementará un código incorrecto, esto en principio sería bastante grave ya que se crearía una aplicación que no tendría el valor que uno esperaba al inicio.
• Es un sistema de desarrollo que no permite la creación de nuevos algoritmos.

Debido al gran éxito que esta metodología está teniendo en el mundo de la ingeniería del software, son muchas y variadas las herramientas que se han ido desarrollando hasta día de hoy. Algunas han surgido en forma de frameworks, otras en formato plug-in bajo el control de algún browser o incluso como librerías para su uso en plataformas de programación.

En mi caso, utilizaré una herramienta llamada JUnit, este es el framework más importante con que cuenta la metodología TDD (Test-driven Development ), de él han ido surgiendo la mayoría de los frameworks del conjunto de los xUnit. Su importancia seguramente radica en que está basado en el lenguaje java que es un lenguaje muy ágil, reusable y adaptable a otros lenguajes y plataformas.

JUnit es utilizado para testear funcionalidades sobre si funcionarán correctamente o no a través de funciones que ya trae consigo el propio framework, como runners para ejecutar directamente los test o asserts para comprobar la validez de los resultados.

Para instalar JUnit seguimos estos pasos:

1. Descargamos la librería d la pagina oficial: Aquí.
2. Descomprimimos el zip en cualquier directorio.
3. Añadir junit.jar al CLASSPATH. Esta operación puede ser diferente según la máquina de que se trate. Por ejemplo, las máquinas arnelaxx tienen el CLASSPATH configurado (bajo linux) por el administrador y no tienes que hacer nada. En cambio, en la máquina java debes añadir la siguiente línea al fichero .profile del directorio principal de tu usuario y luego volver a conectarte:
   export CLASSPATH=$CLASSPATH:/usr/java13_64/lib/fic/junit.jar:.

En caso de utilizar una IDE como Eclipse (mi caso) ya viene incluido la librería de JUnit. Lo único que hay que hacer es abrir la vista de explorador de proyectos, aquí hacer clic con el botón derecho en la clase Test en concreto, en el menú que aparece elegir "Run as" -> "JUnit Test".

En caso que no se encuentre la librería, una vez descargada solo hay que agregarla. Para añadir un jar externo a nuestro proyecto con Eclipse seguimos los siguientes pasos:

• Con el botón derecho del ratón sacamos el menú sobre el proyecto y elegimos "propiedades"
• En la ventana que se abre, en el arbolito de la izquierda elegimos "java build path".
• En el lado derecho de la ventana, elegimos la pestaña "Libraries"
• Le damos al botón "add external jar"
• Buscamos el jar que queremos añadir y lo seleccionamos.
• Aceptar, aceptar, aceptar

y listo, ese jar ya forma parte de nuestro proyecto Eclipse y podemos usarlo en nuestro programa.

 

Con esto corremos la aplicación como una simp'le aplicación java desde Eclipse.

Las puebas se llevaran a cabo en la entrada de taller.

[TALLER] Manejo de eventos, excepciones y errores

En esta entrada mostrare las excepciones en mi proyecto y una breve descripción del porqué se utilizan.

Exception:

public Database(){
  try{
   Class.forName(drv);
   ct =DriverManager.getConnection(db, user, pword);
   st =ct.createStatement();
   System.out.println("Conección exitosa.");
  }catch(Exception e){
   System.out.println("No se pudo conectar a la base de datos.");
  }
 }

En el código anterior se muestra un constructor utilizado para hacer conexión con la base de datos. Todo el código va dentro de un "try" y después un "catch" con una excepción y un mensaje al usuario.

La excepción es del tipo Exception ya que se utiliza la clase Class que solo puede aceptar un tipo de excepción general.

SQLException:

public void showAll(String matt, String pass) {
  String dia = new String();
  Scanner a = new Scanner(System.in);
  System.out.println("Introduzca un dia (Lu, Ma, Mi, Ju, Vi, Sa): ");
  dia = a.next();
  dayselection = dia;
  try{
   do{
    stmt = ct.prepareStatement("SELECT * FROM Alumnos, "+dia+" WHERE  Alumnos.idAlumnos = ? AND Alumnos.idPass = ? AND Alumnos.idAlumnos = "+dia+".idAlumnos");
    stmt.setString(1,matt);
    stmt.setString(2, pass);
    rs = stmt.executeQuery();
    if(rs.next()){
     System.out.println("Seleccione Horario: ");
     String sub = a.next();
     System.out.println(rs.getString(sub));
     subselection=rs.getString(sub);
     fill_data();
     rs.close();
    }
    else{
     System.out.print("Error");
     rs.close();
    }
   }while(rs.isClosed()==false);
  }catch(SQLException e){
   System.out.println("No se pudo realizar la consulta.");
  }
 }

En el código anterior se muestra un método para obtener información de una base de datos a partir de un usuario y una contraseña. Todas las consultas de SQL deben de ir en un try y acompañadas de un catch. En este caso es una excepción del tipo SQLException, que provee información sobre algún error de conexión a la base de datos, en este caso manda al usuario un mensaje de error diciendo que no se pudo conectar a la base de datos.

public void fill_data(){
  try{
   stmt = ct.prepareStatement("SELECT * FROM "+subselection+", "+dayselection+" WHERE "+dayselection+".idAlumnos = "+subselection+".idAlumnos");
   rs = stmt.executeQuery();
   while(rs.next()){
    for(int i=2; i<=9; i++){
     phrs(i);
     if(rs.getString(i) == null){
      System.out.println("Sin Datos");
     }
     else{
      System.out.println(rs.getString(i));
     }
    }

   }
  }catch(SQLException i){
   System.out.println("No tiene materia asignada en ese horario.");
  }
 }

En este caso sucede lo mismo ya que se desea realizar una consulta, este método se encarga de mostrar materias habiendo introducido un horario, de haber un error en la consulta, significa que no existe una materia en el horario seleccionado, de haber cualquier otro tipo de error, el programa jamas habría llegado a este punto.

IOException:

public static void main(String[] args) throws IOException{
  
  boolean selec=true;
  Horario h = new Horario();
  
  Console terminal = System.console();
        if (terminal==null ) {
            System.err.println("No puedo obtener la consola.");
            return;
        }
  String mat = new String (terminal.readLine("Ingresar Usuario: "));
  String pass= new String (terminal.readPassword("Ingresar contraseña: "));
  while(selec == true|| selec ==true){
   h.showAll(mat, pass);
   System.out.print("¿Desea ver otra materia?(S/N): ");
   char sel= (char) System.in.read();
   
    switch(sel) {
    case 's': 
     selec = true;
        break;
        
    case 'S':
     selec=true;
     break;
    
    default:
     selec = false;
        break;
   }
   
   
  }
 }

Existe otra forma de expresar un error, lanzando directamete una excepción sin un try y catch. Este es el método main, y la palabra seguida "throws" que significa lanza, que literalmente lanza una excepción de tipo IOException, es utilizada para mostrar información de errores de entrada y salida.

En este caso, la clase Console siempre debe de ser acompañada de este tipo de excepciones, ya que si se ejecuta el programa desde un lugar distinto de la consola, este lanzara un mensaje de error.

Eventos, excepciones y errores

En esta entrada explicare que son los eventos, errores y excepciones.

Eventos:

Los eventos son todas las acciones que el usuario inicia, dar clic sobre un botón, presionar las teclas del teclado, etc. Cada vez que se produce un evento, se crea un objeto. La clase padre de los eventos es "java.awt.event".

Cada lenguaje de programación tiene su propio modelo de eventos, en Java se definen clases auxiliares llamadas escuchadores (listeners) que reciben eventos específicos.

Los escuchadores se registran en las fuentes de eventos (teclado, ratón, etc). Estas envían objetos del tipo EventObjet la los escuchadores registrados al producirse un evento. Cada escuchador utiliza la información recibida a través del objeto para realizar las acciones adecuadas.

Dentro de "java.awt.event", los eventos están categorizados dentro de una jerarquía de clases.

• La clase "java.util.EventObject" es la clase base de todos los
  eventos en Java.
• La subclase "java.awt.AWTEvent" es la clase base de todos los
  eventos que se utilizan en la construcción de GUIs.
• Cada tipo de evento "xxEvent" tiene asociada una interfaz "xxListener" que es la que nos permite definir escuchadores de eventos.
• Para simplificar la implementación de algunos escuchadores de eventos, el paquete "java.awt.event" incluye clases base xxAdapter que implementan las interfaces xxListener.

Existen distintos tipos de eventos, los cuales son:

Eventos de Ventana

Son los que se generan en respuesta a los cambios de una ventana, un frame o un dialogo.

•     WINDOW_DESTROY
•     WINDOW_EXPOSE
•     WINDOW_ICONIFY
•     WINDOW_DEICONIFY
•     WINDOW_MOVED

Eventos de Teclado

Son generados en respuesta a cuando el usuario pulsa y suelta una tecla mientras un Componente tiene el foco de entrada.

•     KEY_PRESS
•     KEY_RELEASE
•     KEY_ACTION
•     KEY_ACTION_RELEASE

Eventos de Ratón

Son los eventos generados por acciones sobre el ratón dentro de los límites de un Componente.

•     MOUSE_DOWN
•     MOUSE_UP
•     MOUSE_MOVE
•     MOUSE_ENTER
•     MOUSE_EXIT
•     MOUSE_DRAG

Eventos de Barras

Son los eventos generados como respuesta a la manipulación de barras de desplazamiento (scrollbars).

•     SCROLL_LINE_UP
•     SCROLL_LINE_DOWN
•     SCROLL_PAGE_UP
•     SCROLL_PAGE_DOWN
•     SCROLL_ABSOLUTE

Eventos de Lista

Son los eventos generados al seleccionar elementos de una lista.

•     LIST_SELECT
•     LIST_DESELECT

Eventos Varios

Son los eventos generados en función de diversas acciones.

•     ACTION_EVENT
•     LOAD_FILE
•     SAVE_FILE
•     GOT_FOCUS
•     LOST_FOCUS

Errores:

Los errores en la programación suelen ser comunes, ya que es casi imposible programar sin que exista un solo error, inclusive en productos finales existen errores de software, que casi siempre tratan de corregir con parches de seguridad y actualizaciones.

En algún momento por alguna causa, podría generarse algún conflicto en el programa. Ya sea porque no hay conexión a Internet, usuario o contraseña incorrecta, valores alfanuméricos en campos solo para números, y en algunos casos el código del programa no esta escrito correctamente, sin embargo, este ultimo se analizara en el siguiente tema (Diseño de pruebas unitarias).

Existen formas para detectar y corregir errores en un programa por medio de opciones alternativas llamadas excepciones.


Excepciones:

Las excepciones en Java están destinadas, al igual que en el resto de los lenguajes que las soportan, para la detección y corrección de errores.

Si hay un error, la aplicación no debería morirse y generar un core . Se debería lanzar (throw) una excepción que nosotros deberíamos capturar (catch) y resolver la situación de error.

Existen muchos tipos de excepciones,casi una por cada tipo de error, por lo que si tenemos error de entrada/salida de datos, el programa deberia de lanzar una excepción de tipo IOException.

En Java, cada excepción es una clase hija de "java.lang.Exception", por lo que podemos crear nuestras propias excepciones en lugar de utilizar las ya predefinidas.

En este gráfico podemos ver algunos de los errores y excepciones dentro de la clase Throwable que extiende de Object y tiene como hijas a Error y Exception.

[TALLER] Aplicación de patrones de diseño en proyectos individuales

Ahora la implementación de los patrones de diseño, primero comenzare con el Singleton, que recordemos, es para crear objetos solo dentro de la misma clase.

Si en el diagrama no se ve el constructor es por que en este patrón se declara con atributo privado. Aquí el código:

package Organidatabase;

import java.util.Scanner;

public class Notas{
 
 private Notas nuevo = new Notas();
 String nota;
  
  private Notas () {
          System.out.println("Escriba su nota: ");
          Scanner a = new Scanner(System.in);
          nota=a.next();
     }
  
  public Notas new_note() {
   return nuevo;
  }


}

Podemos ver en el código que la creación de un nuevo objeto se restringe solamente a su clase.

Ahora veremos la clase Eventos, donde pretendo utilizar el patrón de diseño Composite.

Puede notarse que en la clase Eventos se están aplicando dos patrones de diseño como lo había dicho en mi entrada de clase, aplican ambas.

package Organidatabase;   
import java.util.ArrayList;
   import java.util.Scanner;

   public abstract class Eventos extends Database{
    String dia;
    String mes;
    String año;
    String hora;
    String lugar;
     
     public Eventos (String dia, String mes, String año, String hora, String lugar) {
      this.dia = dia;
      this.mes = mes;
      this.año = año;
      this.hora = hora;
      this.lugar = lugar;
     }
     
     public abstract void new_event(Eventos e);
       
   }

   abstract class Ev_priv extends Eventos{
    
    private ArrayList hijo = new ArrayList();
    public Ev_priv(String dia, String mes, String año, String hora, String lugar){
     super(lugar, hora, año, mes, dia);
    }
    
    public void new_event(Ev_priv e){
      hijo.add(e);
      System.out.print("Introduzca un fecha: ");
    Scanner a = new Scanner(System.in);
    dia=a.next();
    mes=a.next();
    año=a.next();
    System.out.print("Introduzca la hora: ");
    hora=a.next();
    System.out.print("Introduzca el lugar: ");
    }
}

   abstract class Ev_pub extends Eventos{
     
     ArrayList hijo = new ArrayList();
     public Ev_pub(String dia, String mes, String año, String hora, String lugar){
      super(lugar, hora, año, mes, dia);
     }
     
     public void new_event(Ev_pub e){
       hijo.add(e);
       System.out.print("Introduzca un fecha: ");
     Scanner a = new Scanner(System.in);
     dia=a.next();
     mes=a.next();
     año=a.next();
     System.out.print("Introduzca la hora: ");
     hora=a.next();
     System.out.print("Introduzca el lugar: ");
     }
   }

Por ahora estos son los patrones de diseño que utilizo, sin embargo me he dado cuenta que podemos utilizar muchos patrones en un mismo proyecto por lo que tal vez estos no sean los unicos.