Testing del ORM

En la línea de acción que estamos siguiendo para estabilizar el framework, estamos implementando un set de pruebas para YORM, el componente de ORM de Yupp Framework. Los tests se centran en la generación de las tablas en la base de datos, guardar correctamente estructuras complejas de datos, obtener estructuras complejas de datos desde la base, y verificar restricciones sobre los datos que se intentan guardar en la base.

Con esto lograremos encontrar las debilidades del YORM, al mismo tiempo que demostramos las fortalezas que tiene actualmente.

Los juegos de tests pueden ser descargados del SVN en nuestro sitio en Google Code: http://code.google.com/p/yupp/source/checkout

De esta forma nos acercamos a una versión estable de Yupp Framework, garantizando su poder para crear proyectos web de forma ágil y sencilla, ordenando el desarrollo y evitando las tareas repetitivas.


Actualización:
Uno de los tests que estoy desarrollando es el de probar estructuras de árboles en la base de datos. La prueba consiste en implementar una clase persistente en YORM, la cual es una página web, que a su vez puede tener subpáginas. Aquí está la implementación de la clase:

class Pagina extends PersistentObject
{
   function __construct($args = array (), $isSimpleInstance = false)
   {
      $this->setWithTable("test_a004_pagina");

      $this->addAttribute("titulo",  Datatypes :: TEXT);
      $this->addAttribute("contenido", Datatypes :: TEXT);

      // Pagina padre
      $this->addHasOne('owner', 'Pagina');

      // Paginas hijas
      $this->addHasMany('subpages', 'Pagina');

      $this->addConstraints(
         "titulo",
         array (
            Constraint :: maxLength(255)
         )
      );
      $this->addConstraints(
         "contenido",
         array (
            Constraint :: maxLength(100000)
         )
      );
      $this->addConstraints(
         "owner",
         array (
            Constraint :: nullable(true) // Las paginas del primer nivel no tienen padre.
         )
      );

      parent :: __construct($args, $isSimpleInstance);
   }

   // Mas codigo ...
}

Y ahora la prueba de cómo generar una estructura de árbol y guardarla en la base. Lo que vamos a hacer son 4 instancias de la clase Pagina, la primera es la página raíz, la segunda es hija de la página raíz y las dos restantes son a su vez hijas de esta última. Con el siguiente código no solo creamos la estructura de árbol de páginas, si no que vamos a ver que toda la estructura se guarda automáticamente en la base con una única línea de código por parte del programador!!!

$p1 = new Pagina(
        array(
          "titulo" => "Pagina raiz",
          "contenido" => "This step is usually done transparently as most compilers perform it and then invoke the assembler..."
        )
      );
      $p11 = new Pagina(
        array(
          "titulo" => "Subpagina de raiz 1",
          "contenido" => "This step is usually done transparently as most compilers perform it and then invoke the assembler...",
          "owner" => $p1
        )
      );
      $p111 = new Pagina(
        array(
          "titulo" => "Sub subpagina de raiz 1",
          "contenido" => "This step is usually done transparently as most compilers perform it and then invoke the assembler...",
          "owner" => $p11
        )
      );
      $p112 = new Pagina(
        array(
          "titulo" => "Sub subpagina de raiz 2",
          "contenido" => "This step is usually done transparently as most compilers perform it and then invoke the assembler...",
          "owner" => $p11
        )
      );
      
      
      // subpaginas de p11
      $p11->addToSubpages($p111);
      $p11->addToSubpages($p112);
      
      // subpaginas de p1
      $p1->addToSubpages($p11);
      
      // Guarda toda la estructura con esta única línea de código!
      if (!$p1->save())
      {
         Logger::struct( $p1->getErrors(), "Falla test A004.2 1" );
      }
      else
      {
         echo "Guarda Ok";
      }