• Share
  • Email
  • Embed
  • Like
  • Save
  • Private Content
Realizando Pruebas en la JVM con Velocidad y Eficacia
 

Realizando Pruebas en la JVM con Velocidad y Eficacia

on

  • 1,767 views

Realizando Pruebas en la JVM con Velocidad y Eficacia - SG09

Realizando Pruebas en la JVM con Velocidad y Eficacia - SG09

Statistics

Views

Total Views
1,767
Views on SlideShare
1,766
Embed Views
1

Actions

Likes
2
Downloads
10
Comments
0

1 Embed 1

http://www.slideshare.net 1

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

CC Attribution-NonCommercial LicenseCC Attribution-NonCommercial License

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

    Realizando Pruebas en la JVM con Velocidad y Eficacia Realizando Pruebas en la JVM con Velocidad y Eficacia Presentation Transcript

    • Realizando Pruebas en la JVM con Velocidad y Eficacia Andres Almiray
    • Incrementar la productividad al realizar pruebas en la JVM (  y por qué no?, también la producción de endorfinas)‏
      • Qué es Groovy ?
      • Groovy y frameworks de pruebas
      • Groovy en la runtina diaria
      • Mocks
      • Procesando XML
      • Información adicional
      • Groovy es un lenguaje ágil y dinámico para la Máquina Virtual de Java
      • Basado en los conceptos base del lenguaje Java, incluye características inspiradas en otros lenguajes como Python, Smalltalk y Ruby
      • Habilita características de programación modernas con una curva de aprendizaje plana para desarrolladores Java
      • Soporta Lenguajes de Dominio Específico y otras características de sintaxis corta.
      • Simplifica el ciclo de pruebas dado que soporta pruebas unitarias y mocking desde el inicio.
    • HelloWorld.java
      • public class HelloWorld {
      • String name;
      • public void setName(String name)‏
      • { this .name = name; }
      • public String getName(){ return name; }
      • public String greet()‏
      • { return “Hello “ + name; }
      • public static void main(String args[]){
      • HelloWorld helloWorld = new HelloWorld();
      • helloWorld.setName( “Groovy” );
      • System.err.println( helloWorld.greet() );
      • }
      • }
    • HelloWorld.groovy
      • public class HelloWorld {
      • String name;
      • public void setName(String name)‏
      • { this .name = name; }
      • public String getName(){ return name; }
      • public String greet()‏
      • { return “Hello “ + name; }
      • public static void main(String args[]){
      • HelloWorld helloWorld = new HelloWorld();
      • helloWorld.setName( “Groovy” );
      • System.err.println( helloWorld.greet() );
      • }
      • }
    • Equivalente 100% Groovy
      • class HelloWorld {
      • String name
      • def greet() { "Hello $name" }
      • }
      • def helloWorld = new HelloWorld(name : " Groovy" )‏
      • println helloWorld.greet()‏
    • 1er Mantra
      • Java es Groovy , Groovy es Java
      • Toda clase Java es una clase Groovy , la proposición inversa también es verdadera.
      • Groovy tiene el mismo modelo de memoria y seguridad que Java.
      • El 98% de código Java es código Groovy , en casi todo los casos basta renombrar *.java por *.groovy
    • Cuidado con...
      • La inicialización de arreglos no esta soportada, pero se puede convertir una Lista en un arreglo.
      • Clases internas no soportadas (excepto en Groovy 1.7beta1 donde solo existe soporte para clases anónimas).
    • 2ndo Mantra
      • Groovy es Java y Groovy NO es Java
      • Curva de aprendizaje prácticamente plana.
      • Empieza con sintaxis Java, emigra a sintaxis Groovy conforme pase el tiempo.
      • Groovy provee closures, meta programación, nuevos operadores, sobrecarga de operadores, sintaxis nativa para Mapas y Listas, tipado opcional, etc...
    • Groovy y los frameworks de Prueba
      • Cualquier script de Groovy puede convertirse en un caso de prueba
          • assert habilitado desde el inicio
      • Groovy provee GroovyTestCase como clase base
      • Soporte de Junit 3.x/4.x y TestNG.
      • Groovy permite el uso de características de JDK5+
          • anotaciones, enums, tipos genéricos
    • Groovy en la rutina diaria
      • Escribe menos dado que algunas palabras reservadas son opcionales
          • public, private, protected, return
      • Azúcar sintáctica para uso de propiedades
      • Sintaxis nativa para Mapas y Listas
      • Closures
      • Transformaciones de AST (Arbol de Sintaxis Abstracto)  meta programación en tiempo de compilación
    • Acceso de propieades
      • // Java
      • public class Bean {
      • private String name;
      • public void setName(String n) { name = n; }
      • public String getName() { return name; }
      • }
      • // Groovy
      • Bean bean = new Bean(name: “Duke” )‏
      • assert bean.name == “Duke”
      • bean.name = “Tux”
      • assert bean.name == “Tux”
      • assert bean.name == bean.getName()‏
    • Mapas y Listas
      • Map map = [:]
      • assert map instanceof java.util.Map
      • map[ "key1" ] = "value1"
      • map.key2 = "value2"
      • assert map.size() == 2
      • assert map.key1 == "value1"
      • assert map[ "key2" ] == "value2"
      • List list = []
      • assert list instanceof java.util.List
      • list.add( "One" )‏
      • list << &quot;Two&quot;
      • assert list.size() == 2
      • assert [ &quot;One&quot; , &quot;Two&quot; ] == list
    • Closures (1)‏
      • int count = 0
      • def closure = {->
      • 0.upto(10) { count += it }
      • }
      • closure()‏
      • assert count == (10*11)/2
      • def runnable = closure as Runnable
      • assert runnable instanceof java.lang.Runnable
      • count = 0
      • runnable.run()‏
      • assert count == (10*11)/2
    • Closures (2)‏
      • // un closure con 3 parámetros, el tercero es
      • // opcional dado que define un valor por omisión
      • def getSlope = { x, y, b = 0 ->
      • println &quot;x:${x} y:${y} b:${b}&quot;
      • (y - b) / x
      • }
      • assert 1 == getSlope( 2, 2 )‏
      • def getSlopeX = getSlope.curry(5)‏
      • assert 1 == getSlopeX(5)‏
      • assert 0 == getSlopeX(2.5,2.5)‏
      • // prints
      • // x:2 y:2 b:0
      • // x:5 y:5 b:0
      • // x:5 y:2.5 b:2.5
    • Transformaciones de AST
      • import java.text.SimpleDateFormat
      • class Event {
      • @Delegate Date when
      • String title, url
      • }
      • def df = new SimpleDateFormat( &quot;dd/MM/yyyy&quot; )‏
      • def sg09 = new Event(title: &quot;SG 09&quot; ,
      • url: &quot;http://www.sg.com.mx/sg09/&quot; ,
      • when: df.parse( &quot;28/09/2009&quot; ))‏
      • def so2gx = new Event(title: &quot;SpringOne2GX&quot; ,
      • url: &quot;http://www.springone2gx.com/&quot; ,
      • when: df.parse( &quot;19/10/2009&quot; ))‏
      • assert sg09.before(so2gx.when)‏
    • Transformaciones de AST
      • @Singleton
      • @Lazy
      • @Delegate
      • @Immutable
      • @Bindable
      • @Newify
      • @Category/@Mixin
      • @PackageScope
    • Pero... cómo ejecuto las pruebas?
      • Usa to IDE favorito
          • IDEA
          • Eclipse
          • NetBeans
      • Herramientas de línea de comando
          • Ant
          • Gant
          • Maven
          • Gradle
          • GroovyShell y GroovyConsole
    • Probando excepciones en Java
      • public class JavaExceptionTestCase extends TestCase {
      • public void testExceptionThrowingCode() {
      • try {
      • new MyService().doSomething();
      • fail(&quot;MyService.doSomething has been implemented&quot;);
      • }catch( UnsupportedOperationException expected ){
      • // todo esta BIEN si llegamos a este punto!
      • }
      • }
      • }
    • Probando excepciones en Groovy
      • class GroovyExceptionTestCase extends GroovyTestCase {
      • void testExceptionThrowingCode() {
      • shouldFail( UnsupportedOperationException ){
      • new MyService().doSomething()‏
      • }
      • }
      • }
    • Mocking
      • Groovy no tiene problemas con librerías Java
          • EasyMock – record/replay
          • JMock – define expectativas en el camino
          • Mockito – el recién llegado a la fiesta
      • Proxis dinámicos
      • StubFor/MockFor
    • Proxies Dinámicos
    •  
    • StubFor/MockFor
      • ejecutor – colaborador
      • mocks/stubs definen expectativas en los colaboradores
      • mocks son estrictos, las expectativas deben ser ejecutadas en orden y cardinalidad exacta
      • stubs son mas laxos, las expectativas pueden ser ejecutadas en cualquier orden pero la cardinalidad debe ser respetada.
      • ALERTA : usar solo cuando el ejecutor es código Groovy
    • Groovy Mocks
    •  
    • Procesando XML
      • DbUnit: extensión de Junit para verificar bases de datos
      • Existen varias opciones
        • Típica: extender de DatabaseTestCase
        • Flexible: usar un IDatabaseTester compuesto
        • BYOT: (Build Your Own Testcase)‏
    • XML en linea
      • import org.dbunit.*
      • import org.junit.*
      • class MyDBTestCase {
      • IDatabaseTester db
      • @BeforeClass void init(){
      • db = new JdbcDatabaseTester(&quot;org.hsqldb.jdbcDriver&quot;,
      • &quot;jdbc:hsqldb:sample&quot;, &quot;sa&quot;, &quot;&quot; )‏
      • // insert table schema
      • def dataset = &quot;&quot;&quot;
      • <dataset>
      • <company name=&quot;Acme&quot;/>
      • <employee name=&quot;Duke&quot; company_id=&quot;1&quot;>
      • </dataset>
      • &quot;&quot;&quot;
      • db.dataset = new FlatXmlDataSet( new StringReader(dataset) )‏
      • db.onSetUp()‏
      • }
      • @AfterClass void exit() { db.onTearDown() }
      • }
    • XML verificado por el compilador
      • import org.dbunit.*
      • import org.junit.*
      • Import groovy.xml.MarkupBuilder
      • class MyDBTestCase {
      • IDatabaseTester db
      • @BeforeClass void init(){
      • db = new JdbcDatabaseTester(&quot;org.hsqldb.jdbcDriver&quot;,
      • &quot;jdbc:hsqldb:sample&quot;, &quot;sa&quot;, &quot;&quot; )‏
      • // insert table schema
      • def dataset = new MarkupBuilder().dataset {
      • company( name: Acme )‏
      • employee( name: &quot;Duke&quot;, company_id: 1 )‏
      • }
      • db.dataset = new FlatXmlDataSet( new StringReader(dataset) )‏
      • db.onSetUp()‏
      • }
      • @AfterClass void exit() { db.onTearDown() }
      • }
    • Información Adicional
      • http://groovy.codehaus.org
      • http://junit.org
      • http://testng.org
      • http://dbunit.org
      • http://groovy.dzone.com
      • http://gr8forums.org
    • twitter: @aalmiray blog: http://jroller.com/aalmiray