Modulprogrammierung 2: Datenbankunterstützung

<?php
 
require_once(substr(dirname(__FILE__), 0, -52).'/Framework/PapayaTestCase.php');
require_once(PAPAYA_INCLUDE_PATH.'modules/special/myproject/tutorial/Hello/Planet.php');
 
class HelloPlanetTest extends PapayaTestCase {
  /**
  * Get the HelloPlanet object to be tested
  *
  * @return HelloPlanet
  */
  private function getPlanetObjectFixture() {
    return new HelloPlanet();
  }
 
  /**
  * @covers HelloPlanet::getById
  */
  public function testGetById() {
    $planetObject = $this->getPlanetObjectFixture();
    $expected = array('planet_id' => 1, 'planet_name' => 'Mars');
    $this->assertEquals($expected, $planetObject->getById(1));
  }
 
  /**
  * @covers HelloPlanet::getAll
  */
  public function testGetAll() {
    $planetObject = $this->getPlanetObjectFixture();
    $expected = array(1 => 'Mars', 2 => 'Jupiter', 3 => 'Saturn');
    $this->assertEquals($expected, $planetObject->getAll());
  }
 
  /**
  * @covers HelloPlanet::create
  */
  public function testCreate() {
    $planetObject = $this->getPlanetObjectFixture();
    $data = array('planet_name' => 'Jupiter');
    $this->assertTrue($planetObject->create($data));
  }
 
  /**
  * @covers HelloPlanet::update
  */
  public function testUpdate() {
    $planetObject = $this->getPlanetObjectFixture();
    $data = array('planet_name' => 'Saturn');
    $this->assertTrue($planetObject->update(3, $data));
  }
 
  /**
  * @covers HelloPlanet::delete
  */
  public function testDelete() {
    $planetObject = $this->getPlanetObjectFixture();
    $this->assertTrue($planetObject->delete(2));
  }
}

<?php
 
/**
* Hello World tutorial, Planet class
*
* The Planet class provides the public interface for planets to be stored in
* and loaded from database.
*
* @package Papaya-Modules
* @subpackage tutorial
*/
 
/**
* Hello World tutorial, Planet class
*
* @package Papaya-Modules
* @subpackage tutorial
*/
class HelloPlanet {
  /**
  * Get a planet by id
  *
  * @param integer $planetId id of the planet to load
  * @return mixed array planet data if id exists, FALSE otherwise
  */
  public function getById($planetId) {
    return array('planet_id' => 1, 'planet_name' => 'Mars');
  }
 
  /**
  * Get all planets
  *
  * @return mixed array planet data if planets exist, FALSE otherwise
  */
  public function getAll() {
    return array(1 => 'Mars', 2 => 'Jupiter', 3 => 'Saturn');
  }
 
  /**
  * Add a new planet to the database
  *
  * @param array $data planet data
  * @return boolean TRUE on success, FALSE otherwise
  */
  public function create($data) {
    return TRUE;
  }
 
  /**
  * Modify an existing planet
  *
  * @param integer $planetId id of the planet to modify
  * @param array $data modified planet data
  * @return boolean TRUE on success, FALSE otherwise
  */
  public function update($planetId, $data) {
    return TRUE;
  }
 
  /**
  * Delete a specific planet by id
  *
  * @param integer $planetId
  * @return boolean TRUE on success, FALSE otherwise
  */
  public function delete($planetId) {
    return TRUE;
  }
}

<?php
require_once(substr(dirname(__FILE__), 0, -68).'/Framework/PapayaTestCase.php');
PapayaTestCase::registerPapayaAutoloader();
require_once(PAPAYA_INCLUDE_PATH.'modules/special/myproject/tutorial/Hello/Planet/Database/Access.php');
 
class HelloPlanetDatabaseAccessTest extends PapayaTestCase {
  /**
  * Get the HelloPlanetDatabaseAccess object to be tested
  *
  * @return HelloPlanetDatabaseAccess
  */
  private function getPlanetDatabaseAccessObjectFixture() {
    return new HelloPlanetDatabaseAccess();
  }
 
  /**
  * Get a PapayaDatabaseAccess mock object
  *
  * @param array $methods the methods to be modeled
  * @return PapayaDatabaseAccess mock object
  */
  private function getPapayaDatabaseAccessObjectFixture($methods) {
    if (!in_array('getTableName', $methods)) {
      $methods[] = 'getTableName';
    }
    $databaseAccessObject = $this->getMock(
      'PapayaDatabaseAccess',
      $methods,
      array(),
      'Mock_'.md5(__CLASS__.microtime()),
      FALSE
    );
    $databaseAccessObject
      ->expects($this->once())
      ->method('getTableName')
      ->with($this->equalTo('tutorial_planets'), $this->isTrue())
      ->will($this->returnValue('papaya_tutorial_planets'));
    return $databaseAccessObject;
  }
 
  /**
  * Get a database result mock object
  *
  * @param array $methods List of methods to be mocked
  * @return dbresult_mysql mock object
  */
  private function getDatabaseResultObjectFixture($methods) {
    if (!defined('DB_FETCHMODE_ASSOC')) {
      define('DB_FETCHMODE_ASSOC', 0);
    }
    return $this->getMock(
      'dbresult_mysql',
      $methods,
      array(),
      'Mock_'.md5(__CLASS__.microtime()),
      FALSE
    );
  }
 
  /**
  * @covers HelloPlanetDatabaseAccess::getById
  */
  public function testGetById() {
    $planetDatabaseAccessObject = $this->getPlanetDatabaseAccessObjectFixture();
    $databaseAccessObject = $this->getPapayaDatabaseAccessObjectFixture(
      array('queryFmt')
    );
    $databaseResultObject = $this->getDatabaseResultObjectFixture(
      array('fetchRow')
    );
    $expectedData = array('planet_id' => 1, 'planet_name' => 'Mars');
    $databaseResultObject
      ->expects($this->once())
      ->method('fetchRow')
      ->will($this->returnValue($expectedData));
    $databaseAccessObject
      ->expects($this->once())
      ->method('queryFmt')
      ->will($this->returnValue($databaseResultObject));
    $planetDatabaseAccessObject->setDatabaseAccess($databaseAccessObject);
    $this->assertEquals($expectedData, $planetDatabaseAccessObject->getById(1));
  }
 
  /**
  * @covers HelloPlanetDatabaseAccess::getAll
  */
  public function testGetAll() {
    $planetDatabaseAccessObject = $this->getPlanetDatabaseAccessObjectFixture();
    $databaseAccessObject = $this->getPapayaDatabaseAccessObjectFixture(
      array('queryFmt')
    );
    $databaseResultObject = $this->getDatabaseResultObjectFixture(
      array('fetchRow')
    );
    $expectedData = array(
      array('planet_id' => 1, 'planet_name' => 'Mars'),
      array('planet_id' => 2, 'planet_name' => 'Jupiter'),
      array('planet_id' => 3, 'planet_name' => 'Saturn')
    );
    $databaseResultObject
      ->expects($this->atLeastOnce())
      ->method('fetchRow')
      ->will(
          $this->onConsecutiveCalls(
            $this->returnValue($expectedData[0]),
            $this->returnValue($expectedData[1]),
            $this->returnValue($expectedData[2]),
            FALSE
          )
        );
    $databaseAccessObject
      ->expects($this->once())
      ->method('queryFmt')
      ->will($this->returnValue($databaseResultObject));
    $planetDatabaseAccessObject->setDatabaseAccess($databaseAccessObject);
    $expectedResult = array();
    foreach ($expectedData as $row) {
      $expectedResult[$row['planet_id']] = $row['planet_name'];
    }
    $this->assertEquals($expectedResult, $planetDatabaseAccessObject->getAll());
  }
 
  /**
  * @covers HelloPlanetDatabaseAccess::create
  */
  public function testCreate() {
    $planetDatabaseAccessObject = $this->getPlanetDatabaseAccessObjectFixture();
    $databaseAccessObject = $this->getPapayaDatabaseAccessObjectFixture(
      array('insertRecord')
    );
    $databaseAccessObject
      ->expects($this->once())
      ->method('insertRecord')
      ->will($this->returnValue(1));
    $planetDatabaseAccessObject->setDatabaseAccess($databaseAccessObject);
    $this->assertTrue($planetDatabaseAccessObject->create(array('planet_name' => 'Mars')));
  }
 
  /**
  * @covers HelloPlanetDatabaseAccess::update
  */
  public function testUpdate() {
    $planetDatabaseAccessObject = $this->getPlanetDatabaseAccessObjectFixture();
    $databaseAccessObject = $this->getPapayaDatabaseAccessObjectFixture(
      array('updateRecord')
    );
    $databaseAccessObject
      ->expects($this->once())
      ->method('updateRecord')
      ->will($this->returnValue(1));
    $planetDatabaseAccessObject->setDatabaseAccess($databaseAccessObject);
    $this->assertTrue($planetDatabaseAccessObject->update(2, array('planet_name' => 'Jupiter')));
  }
 
  /**
  * @covers HelloPlanetDatabaseAccess::delete
  */
  public function testDelete() {
    $planetDatabaseAccessObject = $this->getPlanetDatabaseAccessObjectFixture();
    $databaseAccessObject = $this->getPapayaDatabaseAccessObjectFixture(
      array('deleteRecord')
    );
    $databaseAccessObject
      ->expects($this->once())
      ->method('deleteRecord')
      ->will($this->returnValue(1));
    $planetDatabaseAccessObject->setDatabaseAccess($databaseAccessObject);
    $this->assertTrue($planetDatabaseAccessObject->delete(9));
  }
}

<?php
/**
* Hello World tutorial, Planet database access class
*
* The Planet database access class provides the internal functionality
* to store planets in and load them from the database
*
* @package Papaya-Modules
* @subpackage tutorial
*/
 
/**
* Hello World tutorial, Planet database access class
*
* @package Papaya-Modules
* @subpackage tutorial
*/
class HelloPlanetDatabaseAccess extends PapayaDatabaseObject {
  /**
  * Database table planets
  * @var string
  */
  private $_tablePlanets = 'tutorial_planets';
 
  /**
  * Get a planet by id
  *
  * @param integer $planetId id of the planet to load
  * @return mixed array planet data if id exists, FALSE otherwise
  */
  public function getById($planetId) {
    $sql = "SELECT planet_id, planet_name
              FROM %s
             WHERE planet_id = %d";
    $params = array($this->databaseGetTableName($this->_tablePlanets, TRUE), $planetId);
    $result = FALSE;
    if ($res = $this->databaseQueryFmt($sql, $params)) {
      if ($row = $res->fetchRow(DB_FETCHMODE_ASSOC)) {
        $result = $row;
      }
    }
    return $result;
  }
 
  /**
  * Get all planets
  *
  * The return value is an array in which the keys are planet ids and the values are planet names.
  * If no planets exist, the return value will be FALSE.
  *
  * @return mixed array planet data if planets exist, FALSE otherwise
  */
  public function getAll() {
    $sql = "SELECT planet_id, planet_name
              FROM %s";
    $params = array($this->databaseGetTableName($this->_tablePlanets, TRUE));
    $result = FALSE;
    if ($res = $this->databaseQueryFmt($sql, $params)) {
      while ($row = $res->fetchRow(DB_FETCHMODE_ASSOC)) {
        if ($result === FALSE) {
          $result = array();
        }
        $result[$row['planet_id']] = $row['planet_name'];
      }
    }
    return $result;
  }
 
  /**
  * Add a new planet to the database
  *
  * @param array $data planet data
  * @return boolean TRUE on success, FALSE otherwise
  */
  public function create($data) {
    $result = FALSE;
    $success = $this->databaseInsertRecord(
      $this->databaseGetTableName($this->_tablePlanets, TRUE),
      'planet_id',
      $data
    );
    if ($success !== FALSE) {
      $result = TRUE;
    }
    return $result;
  }
 
  /**
  * Modify an existing planet
  *
  * @param integer $planetId id of the planet to modify
  * @param array $data modified planet data
  * @return boolean TRUE on success, FALSE otherwise
  */
  public function update($planetId, $data) {
    $result = FALSE;
    $success = $this->databaseUpdateRecord(
      $this->databaseGetTableName($this->_tablePlanets, TRUE),
      $data,
      'planet_id',
      $planetId
    );
    if ($success !== FALSE) {
      $result = TRUE;
    }
    return $result;
  }
 
  /**
  * Delete a specific planet by id
  *
  * @param integer $planetId
  * @return boolean TRUE on success, FALSE otherwise
  */
  public function delete($planetId) {
    $result = FALSE;
    $success = $this->databaseDeleteRecord(
      $this->databaseGetTableName($this->_tablePlanets, TRUE),
      'planet_id',
      $planetId
    );
    if ($success !== FALSE) {
      $result = TRUE;
    }
    return $result;
  }
}

<?php
require_once(substr(dirname(__FILE__), 0, -52).'/Framework/PapayaTestCase.php');
PapayaTestCase::registerPapayaAutoloader();
require_once(PAPAYA_INCLUDE_PATH.'modules/special/myproject/tutorial/Hello/Planet.php');
require_once(PAPAYA_INCLUDE_PATH.'modules/special/myproject/tutorial/Hello/Planet/Database/Access.php');
 
class HelloPlanetTest extends PapayaTestCase {
  /**
  * Get the HelloPlanet object to be tested
  *
  * @return HelloPlanet
  */
  private function getPlanetObjectFixture() {
    return new HelloPlanet();
  }
 
  /**
  * Get a HelloPlanetDatabaseAccess mock object fixture
  *
  * @return HelloPlanetDatabaseAccess mock object
  */
  private function getDatabaseAccessObjectFixture() {
    return $this->getMock('HelloPlanetDatabaseAccess');
  }
 
  /**
  * @covers HelloPlanet::setDatabaseAccessObject
  */
  public function testSetDatabaseAccessObject() {
    $planetObject = $this->getPlanetObjectFixture();
    $databaseAccessObject = $this->getDatabaseAccessObjectFixture();
    $planetObject->setDatabaseAccessObject($databaseAccessObject);
    $this->assertAttributeSame($databaseAccessObject, '_databaseAccessObject', $planetObject);
  }
 
  /**
  * @covers HelloPlanet::getDatabaseAccessObject
  */
  public function testGetDatabaseAccessObject() {
    $planetObject = $this->getPlanetObjectFixture();
    $databaseAccessObject = $planetObject->getDatabaseAccessObject();
    $this->assertAttributeInstanceOf(
      'HelloPlanetDatabaseAccess',
      '_databaseAccessObject',
      $planetObject
    );
  }
 
  /**
  * @covers HelloPlanet::getById
  */
  public function testGetById() {
    $planetObject = $this->getPlanetObjectFixture();
    $databaseAccessObject = $this->getDatabaseAccessObjectFixture();
    $expected = array('planet_id' => 1, 'planet_name' => 'Mars');
    $databaseAccessObject
      ->expects($this->once())
      ->method('getById')
      ->will($this->returnValue($expected));
    $planetObject->setDatabaseAccessObject($databaseAccessObject);
    $this->assertEquals($expected, $planetObject->getById(1));
  }
 
  /**
  * @covers HelloPlanet::getAll
  */
  public function testGetAll() {
    $planetObject = $this->getPlanetObjectFixture();
    $databaseAccessObject = $this->getDatabaseAccessObjectFixture();
    $expected = array(1 => 'Mars', 2 => 'Jupiter', 3 => 'Saturn');
    $databaseAccessObject
      ->expects($this->once())
      ->method('getAll')
      ->will($this->returnValue($expected));
    $planetObject->setDatabaseAccessObject($databaseAccessObject);
    $this->assertEquals($expected, $planetObject->getAll());
  }
 
  /**
  * @covers HelloPlanet::create
  */
  public function testCreate() {
    $planetObject = $this->getPlanetObjectFixture();
    $databaseAccessObject = $this->getDatabaseAccessObjectFixture();
    $databaseAccessObject
      ->expects($this->once())
      ->method('create')
      ->will($this->returnValue(TRUE));
    $planetObject->setDatabaseAccessObject($databaseAccessObject);
    $data = array('planet_name' => 'Jupiter');
    $this->assertTrue($planetObject->create($data));
  }
 
  /**
  * @covers HelloPlanet::update
  */
  public function testUpdate() {
    $planetObject = $this->getPlanetObjectFixture();
    $databaseAccessObject = $this->getDatabaseAccessObjectFixture();
    $databaseAccessObject
      ->expects($this->once())
      ->method('update')
      ->will($this->returnValue(TRUE));
    $planetObject->setDatabaseAccessObject($databaseAccessObject);
    $data = array('planet_name' => 'Saturn');
    $this->assertTrue($planetObject->update(3, $data));
  }
 
  /**
  * @covers HelloPlanet::delete
  */
  public function testDelete() {
    $planetObject = $this->getPlanetObjectFixture();
    $databaseAccessObject = $this->getDatabaseAccessObjectFixture();
    $databaseAccessObject
      ->expects($this->once())
      ->method('delete')
      ->will($this->returnValue(TRUE));
    $planetObject->setDatabaseAccessObject($databaseAccessObject);
    $this->assertTrue($planetObject->delete(2));
  }
}

<?php
/**
* Hello World tutorial, Planet class
*
* The Planet class provides the public interface for planets to be stored in
* and loaded from database.
*
* @package Papaya-Modules
* @subpackage tutorial
*/
 
/**
* Hello World tutorial, Planet class
*
* @package Papaya-Modules
* @subpackage tutorial
*/
class HelloPlanet {
  /**
  * The HelloPlanetDatabaseAccess object to be used
  * @var HelloPlanetDatabaseAccess
  */
  private $_databaseAccessObject = NULL;
 
  /**
  * Set the HelloPlanetDatabaseAccess object to be used
  *
  * @param HelloPlanetDatabaseAccess $databaseAccessObject
  */
  public function setDatabaseAccessObject($databaseAccessObject) {
    $this->_databaseAccessObject = $databaseAccessObject;
  }
 
  /**
  * Get (and, if necessary, initialize) the HelloPlanetDatabaseAccess object
  *
  * @return HelloPlanetDatabaseAccess
  */
  public function getDatabaseAccessObject() {
    if (!is_object($this->_databaseAccessObject)) {
      include_once(dirname(__FILE__).'/Planet/Database/Access.php');
      $this->_databaseAccessObject = new HelloPlanetDatabaseAccess();
    }
    return $this->_databaseAccessObject;
  }
 
  /**
  * Get a planet by id
  *
  * @param integer $planetId id of the planet to load
  * @return mixed array planet data if id exists, FALSE otherwise
  */
  public function getById($planetId) {
    $databaseAccessObject = $this->getDatabaseAccessObject();
    return $databaseAccessObject->getById($planetId);
  }
 
  /**
  * Get all planets
  *
  * @return mixed array planet data if planets exist, FALSE otherwise
  */
  public function getAll() {
    $databaseAccessObject = $this->getDatabaseAccessObject();
    return $databaseAccessObject->getAll();
  }
 
  /**
  * Add a new planet to the database
  *
  * @param array $data planet data
  * @return boolean TRUE on success, FALSE otherwise
  */
  public function create($data) {
    $databaseAccessObject = $this->getDatabaseAccessObject();
    return $databaseAccessObject->create($data);
  }
 
  /**
  * Modify an existing planet
  *
  * @param integer $planetId id of the planet to modify
  * @param array $data modified planet data
  * @return boolean TRUE on success, FALSE otherwise
  */
  public function update($planetId, $data) {
    $databaseAccessObject = $this->getDatabaseAccessObject();
    return $databaseAccessObject->update($planetId, $data);
  }
 
  /**
  * Delete a specific planet by id
  *
  * @param integer $planetId
  * @return boolean TRUE on success, FALSE otherwise
  */
  public function delete($planetId) {
    $databaseAccessObject = $this->getDatabaseAccessObject();
    return $databaseAccessObject->delete($planetId);
  }
}

<?php
require_once(substr(dirname(__FILE__), 0, -52).'/Framework/PapayaTestCase.php');
PapayaTestCase::registerPapayaAutoloader();
require_once(PAPAYA_INCLUDE_PATH.'modules/special/myproject/tutorial/Hello/Connector.php');
require_once(PAPAYA_INCLUDE_PATH.'modules/special/myproject/tutorial/Hello/Planet.php');
 
class HelloConnectorTest extends PapayaTestCase {
  /**
  * @covers HelloConnector::setPlanetObject
  */
  public function testSetPlanetObject() {
    $helloConnectorObject = new HelloConnector_TestProxy();
    $planetObject = $this->getMock('HelloPlanet');
    $helloConnectorObject->setPlanetObject($planetObject);
    $this->assertAttributeSame($planetObject, '_planetObject', $helloConnectorObject);
  }
 
  /**
  * @covers HelloConnector::getPlanetObject
  */
  public function testGetPlanetObject() {
    $helloConnectorObject = HelloConnector_TestProxy();
    $planetObject = $helloConnectorObject->getPlanetObject();
    $this->assertInstanceOf('HelloPlanet', $planetObject);
  }
 
  /**
  * @covers HelloConnector::getPlanetById
  */
  public function testGetPlanetById() {
    $helloConnectorObject = HelloConnector_TestProxy();
    $planetObject = $this->getMock('HelloPlanet');
    $expected = array('planet_id' => 1, 'planet_name' => 'Mars');
    $planetObject
      ->expects($this->once())
      ->method('getById')
      ->will($this->returnValue($expected));
    $helloConnectorObject->setPlanetObject($planetObject);
    $this->assertEquals($expected, $helloConnectorObject->getPlanetById(1));
  }
 
  /**
  * @covers HelloConnector::getAllPlanets
  */
  public function testGetAllPlanets() {
    $helloConnectorObject = HelloConnector_TestProxy();
    $planetObject = $this->getMock('HelloPlanet');
    $expected = array(1 => 'Mars', 2 => 'Jupiter', 3 => 'Saturn');
    $planetObject
      ->expects($this->once())
      ->method('getAll')
      ->will($this->returnValue($expected));
    $helloConnectorObject->setPlanetObject($planetObject);
    $this->assertEquals($expected, $helloConnectorObject->getAllPlanets());
  }
 
  /**
  * @covers HelloConnector::createPlanet
  */
  public function testCreatePlanet() {
    $helloConnectorObject = HelloConnector_TestProxy();
    $planetObject = $this->getMock('HelloPlanet');
    $planetObject
      ->expects($this->once())
      ->method('create')
      ->will($this->returnValue(TRUE));
    $helloConnectorObject->setPlanetObject($planetObject);
    $this->assertTrue(
      $helloConnectorObject->createPlanet(array('planet_name' => 'Neptune'))
    );
  }
 
  /**
  * @covers HelloConnector::updatePlanet
  */
  public function testUpdatePlanet() {
    $helloConnectorObject = HelloConnector_TestProxy();
    $planetObject = $this->getMock('HelloPlanet');
    $planetObject
      ->expects($this->once())
      ->method('update')
      ->will($this->returnValue(TRUE));
    $helloConnectorObject->setPlanetObject($planetObject);
    $this->assertTrue(
      $helloConnectorObject->updatePlanet(1, array('planet_name' => 'Mars'))
    );
  }
 
  /**
  * @covers HelloConnector::deletePlanet
  */
  public function testDeletePlanet() {
    $helloConnectorObject = HelloConnector_TestProxy();
    $planetObject = $this->getMock('HelloPlanet');
    $planetObject
      ->expects($this->once())
      ->method('delete')
      ->will($this->returnValue(TRUE));
    $helloConnectorObject->setPlanetObject($planetObject);
    $this->assertTrue($helloConnectorObject->deletePlanet(2));
  }
}
 
class HelloConnector_TestProxy extends HelloConnector {
  public function __construct() {
    // Nothing to do here; just provide a constructor without parameters
  }
}

<?php
/**
* Hello World tutorial, connector class
*
* The connector class provides the base methods to be used by content and admin modules.
*
* @package Papaya-Modules
* @subpackage tutorial
*/
 
/**
* Base class base_connector
*/
require_once(PAPAYA_INCLUDE_PATH.'system/base_connector.php');
 
/**
* Hello World tutorial, connector class
*
* @package Papaya-Modules
* @subpackage tutorial
*/
class HelloConnector extends base_connector {
  /**
  * The HelloPlanet object to be used
  * @var HelloPlanet
  */
  protected $_planetObject = NULL;
 
  /**
  * Set the HelloPlanet object to be used
  *
  * @param HelloPlanet $planetObject
  */
  public function setPlanetObject($planetObject) {
    $this->_planetObject = $planetObject;
  }
 
  /**
  * Get (and, if necessary, initialize) the HelloPlanet object
  *
  * @return HelloPlanet
  */
  public function getPlanetObject() {
    if (!is_object($this->_planetObject)) {
      include_once(dirname(__FILE__).'/Planet.php');
      $this->_planetObject = new HelloPlanet();
    }
    return $this->_planetObject;
  }
 
  /**
  * Get a planet by id
  *
  * @param integer $planetId
  * @return mixed array if the planet exists, FALSE otherwise
  */
  public function getPlanetById($planetId) {
    $planetObject = $this->getPlanetObject();
    return $planetObject->getById($planetId);
  }
 
  /**
  * Get all planets
  *
  * @return mixed array if planets exist, FALSE otherwise
  */
  public function getAllPlanets() {
    $planetObject = $this->getPlanetObject();
    return $planetObject->getAll();
  }
 
  /**
  * Insert a new planet
  *
  * @param array $planetData
  * @return boolean TRUE on success, FALSE otherwise
  */
  public function createPlanet($data) {
    $planetObject = $this->getPlanetObject();
    return $planetObject->create($data);
  }
 
  /**
  * Update a planet
  *
  * @param integer $planetId
  * @param array $data
  * @return boolean TRUE on success, FALSE otherwise
  */
  public function updatePlanet($planetId, $data) {
    $planetObject = $this->getPlanetObject();
    return $planetObject->update($planetId, $data);
  }
 
  /**
  * Delete a planet
  *
  * @param integer $planetId
  * @return boolean TRUE on success, FALSE otherwise
  */
  public function deletePlanet($planetId) {
    $planetObject = $this->getPlanetObject();
    return $planetObject->delete($planetId);
  }
}

  $pluginloader = new base_pluginloader();
  $connectorObject = $pluginloader->getPluginInstance($connectorGuid, $owner);

<?php
 
require_once(substr(__FILE__, 0, -63).'/Framework/PapayaTestCase.php');
PapayaTestCase::registerPapayaAutoloader();
require_once(PAPAYA_INCLUDE_PATH.'modules/special/myproject/tutorial/Hello/Page/Base.php');
require_once(PAPAYA_INCLUDE_PATH.'modules/special/myproject/tutorial/Hello/Connector.php');
 
class HelloPageTest extends PapayaTestCase {
  /**
  * Instantiate the HelloPageBase object to be tested
  *
  * @return HelloPageBase
  */
  private function getHelloPageBaseObjectFixture() {
    $this->defineConstantDefaults('PAPAYA_DB_TBL_MODULES');
    return new HelloPageBase();
  }
 
  /**
  * Get an owner mock object (it doesn't need a specific class)
  *
  * @return object
  */
  private function getOwnerObjectFixture() {
    return $this->getMock('GenericContentClass');
  }
 
  /**
  * Get a base_pluginloader mock object
  *
  * @return base_pluginloader mock object
  */
  private function getPluginloaderObjectFixture() {
    return $this->getMock('base_pluginloader');
  }
 
  /**
  * Get a HelloConnector mock object
  *
  * @return HelloConnector mock object
  */
  private function getHelloConnectorObjectFixture() {
    return $this->getMock(
      'HelloConnector',
      array(),
      array(),
      'Mock_'.md5(__CLASS__.microtime()),
      FALSE
    );
  }
 
  /**
  * @covers HelloPageBase::setOwner
  */
  public function testSetOwner() {
    $helloPageBaseObject = $this->getHelloPageBaseObjectFixture();
    $owner = $this->getOwnerObjectFixture();
    $helloPageBaseObject->setOwner($owner);
    $this->assertAttributeSame($owner, '_owner', $helloPageBaseObject);
  }
 
  /**
  * @covers HelloPageBase::setPluginloaderObject
  */
  public function testSetPluginloaderObject() {
    $helloPageBaseObject = $this->getHelloPageBaseObjectFixture();
    $pluginloaderObject = $this->getPluginloaderObjectFixture();
    $helloPageBaseObject->setPluginloaderObject($pluginloaderObject);
    $this->assertAttributeSame(
      $pluginloaderObject,
      '_pluginloaderObject',
      $helloPageBaseObject
    );
  }
 
  /**
  * @covers HelloPageBase::getPluginloaderObject
  */
  public function testGetPluginloaderObject() {
    $helloPageBaseObject = $this->getHelloPageBaseObjectFixture();
    $pluginloaderObject = $helloPageBaseObject->getPluginloaderObject();
    $this->assertInstanceOf('base_pluginloader', $pluginloaderObject);
  }
 
  /**
  * @covers HelloPageBase::setHelloConnectorObject
  */
  public function testSetHelloConnectorObject() {
    $helloPageBaseObject = $this->getHelloPageBaseObjectFixture();
    $helloConnectorObject = $this->getHelloConnectorObjectFixture();
    $helloPageBaseObject->setHelloConnectorObject($helloConnectorObject);
    $this->assertAttributeSame(
      $helloConnectorObject,
      '_helloConnectorObject',
      $helloPageBaseObject
    );
  }
 
  /**
  * @covers HelloPageBase::getHelloConnectorObject
  */
  public function testGetHelloConnectorObject() {
    $helloPageBaseObject = $this->getHelloPageBaseObjectFixture();
    $owner = $this->getOwnerObjectFixture();
    $pluginloaderObject = $this->getPluginloaderObjectFixture();
    $helloConnectorObject = $this->getHelloConnectorObjectFixture();
    $pluginloaderObject
      ->expects($this->once())
      ->method('getPluginInstance')
      ->will($this->returnValue($helloConnectorObject));
    $helloPageBaseObject->setOwner($owner);
    $helloPageBaseObject->setPluginloaderObject($pluginloaderObject);
    $this->assertSame(
      $helloConnectorObject,
      $helloPageBaseObject->getHelloConnectorObject()
    );
  }
 
  // testSetPageData() und testGetPageXml() bleiben, wie sie waren
}

  /**
  * Owner object
  * @var HelloPage
  */
  private $_owner = NULL;
 
  /**
  * base_pluginloader object
  * @var base_pluginloader
  */
  private $_pluginloaderObject = NULL;
 
  /**
  * HelloConnector object
  * @var HelloConnector
  */
  private $_helloConnectorObject = NULL;
 
  /**
  * Page configuration data
  * @var array
  */
  private $_data = array();
 
  /**
  * Set owner object
  *
  * @param HelloPage $owner
  */
  public function setOwner($owner) {
    $this->_owner = $owner;
  }
 
  /**
  * Set the base_pluginloader object to use
  *
  * @param base_pluginloader $pluginloaderObject
  */
  public function setPluginloaderObject($pluginloaderObject) {
    $this->_pluginloaderObject = $pluginloaderObject;
  }
 
  /**
  * Get (and, if necessary, initialize) the base_pluginloader object
  *
  * @return base_pluginloader
  */
  public function getPluginloaderObject() {
    if (!is_object($this->_pluginloaderObject)) {
      $this->_pluginloaderObject = new base_pluginloader();
    }
    return $this->_pluginloaderObject;
  }
 
  /**
  * Set the HelloConnector object to use
  *
  * @param HelloConnector $helloConnectorObject
  */
  public function setHelloConnectorObject($helloConnectorObject) {
    $this->_helloConnectorObject = $helloConnectorObject;
  }
 
  /**
  * Get (and, if necessary, initialize) the HelloConnector object
  *
  * @return HelloConnector
  */
  public function getHelloConnectorObject() {
    if (!is_object($this->_helloConnectorObject)) {
      $pluginloaderObject = $this->getPluginloaderObject();
      $this->_helloConnectorObject = $pluginloaderObject->getPluginInstance(
        'eeb42aad2491cd607c7c64bc57eae455', $this->_owner
      );
    }
    return $this->_helloConnectorObject;
  }

  /**
  * @covers HelloPageBase::getPageXml
  */
  public function testGetPageXml() {
    $helloPageBaseObject = $this->getHelloPageBaseObjectFixture();
    $helloConnectorObject = $this->getHelloConnectorObjectFixture();
    $helloConnectorObject
      ->expects($this->once())
      ->method('getPlanetById')
      ->will($this->returnValue(array('planet_id' => 1, 'planet_name' => 'Mars')));
    $helloPageBaseObject->setHelloConnectorObject($helloConnectorObject);
    $helloPageBaseObject->setPageData(array('planet_id' => 1, 'text' => 'Hello'));
    $xml = '<title>Hello Mars!</title>
<text>Hello</text>';
    $this->assertEquals($xml, $helloPageBaseObject->getPageXml());
  }

  /**
  * Get the page's XML output
  *
  * @return string XML
  */
  public function getPageXml() {
    $helloConnectorObject = $this->getHelloConnectorObject();
    $planet = '';
    $planetData = $helloConnectorObject->getPlanetById($this->_data['planet_id']);
    if (is_array($planetData) && !empty($planetData)) {
      $planet = $planetData['planet_name'];
    }
    $result = sprintf('<title>Hello %s!</title>'.LF, $planet);
    $result .= sprintf('<text>%s</text>', papaya_strings::escapeHTMLChars($this->_data['text']));
    return $result;
  }

  /**
  * @covers HelloPageBase::getPlanetSelector
  */
  public function testGetPlanetSelector() {
    $helloPageBaseObject = $this->getHelloPageBaseObjectFixture();
    $owner = $this->getOwnerObjectFixture();
    $owner->paramName = 'tut';
    $helloConnectorObject = $this->getHelloConnectorObjectFixture();
    $helloConnectorObject
      ->expects($this->once())
      ->method('getAllPlanets')
      ->will($this->returnValue(array(1 => 'Mars', 2 => 'Jupiter')));
    $helloPageBaseObject->setOwner($owner);
    $helloPageBaseObject->setHelloConnectorObject($helloConnectorObject);
    $expectedXml = '<select name="tut[planet_id]" class="dialogSelect dialogScale">
<option value="1" selected="selected">Mars</option>
<option value="2">Jupiter</option>
</select>';
    $this->assertEquals(
      $expectedXml,
      $helloPageBaseObject->getPlanetSelector('planet_id', 1)
    );
  }

  /**
  * Get a select box for planets
  *
  * @param string $name
  * @param integer $data
  */
  public function getPlanetSelector($name, $data) {
    $result = '';
    $helloConnectorObject = $this->getHelloConnectorObject();
    $planetList = $helloConnectorObject->getAllPlanets();
    if (is_array($planetList) && !empty($planetList)) {
      $result = sprintf(
        '<select name="%s[%s]" class="dialogSelect dialogScale">'.LF,
        $this->_owner->paramName,
        $name
      );
      foreach ($planetList as $planetId => $planetName) {
        $selected = ($planetId == $data) ? ' selected="selected"' : '';
        $result .= sprintf(
          '<option value="%d"%s>%s</option>'.LF,
          $planetId,
          $selected,
          $planetName
        );
      }
      $result .= '</select>';
    }
    return $result;
  }

    $baseObject->setOwner($this);

  /**
  * Edit fields for page configuration
  * @var array
  */
  public $editFields = array(
    'text' => array(
      'Text',
      'isNoHTML',
      TRUE,
      'textarea',
      5,
      '',
      'Greetings from the new module'
    ),
    'planet_id' => array(
      'Planet',
      'isNum',
      FALSE,
      'function',
      'callbackPlanetSelector'
    )
  );

  /**
  * @covers HelloPage::callbackPlanetSelector
  */
  public function testGetCallbackPlanetSelector() {
    $helloPageObject = $this->getHelloPageObjectFixture();
    $helloPageBaseObject = $this->getMock('HelloPageBase');
    $helloPageBaseObject
      ->expects($this->once())
      ->method('getPlanetSelector')
      ->will($this->returnValue('<select />'));
    $helloPageObject->setBaseObject($helloPageBaseObject);
    $this->assertEquals(
      '<select />',
      $helloPageObject->callbackPlanetSelector('planet_id', array(), 1)
    );
  }

  /**
  * Callback method for a planet select field
  *
  * @param string $name
  * @param array $field
  * @param integer $data
  * @return string XML
  */
  public function callbackPlanetSelector($name, $field, $data) {
    $baseObject = $this->getBaseObject();
    $baseObject->setOwner($this);
    return $baseObject->getPlanetSelector($name, $data);
  }