tests/phpunit/CiviTest/CiviUnitTestCase.php

   1 <?php
   2 /**
   3  *  File for the CiviUnitTestCase class
   4  *
   5  *  (PHP 5)
   6  *
   7  * @copyright Copyright CiviCRM LLC (C) 2009
   8  * @license   http://www.fsf.org/licensing/licenses/agpl-3.0.html
   9  *              GNU Affero General Public License version 3
  10  * @package   CiviCRM
  11  *
  12  *   This file is part of CiviCRM
  13  *
  14  *   CiviCRM is free software; you can redistribute it and/or
  15  *   modify it under the terms of the GNU Affero General Public License
  16  *   as published by the Free Software Foundation; either version 3 of
  17  *   the License, or (at your option) any later version.
  18  *
  19  *   CiviCRM is distributed in the hope that it will be useful,
  20  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  *   GNU Affero General Public License for more details.
  23  *
  24  *   You should have received a copy of the GNU Affero General Public
  25  *   License along with this program.  If not, see
  26  *   <http://www.gnu.org/licenses/>.
  27  */
  28
  29 /**
  30  *  Include configuration
  31  */
  32 define('CIVICRM_SETTINGS_PATH', __DIR__ . '/civicrm.settings.dist.php');
  33 define('CIVICRM_SETTINGS_LOCAL_PATH', __DIR__ . '/civicrm.settings.local.php');
  34
  35 if (file_exists(CIVICRM_SETTINGS_LOCAL_PATH)) {
  36   require_once CIVICRM_SETTINGS_LOCAL_PATH;
  37 }
  38 require_once CIVICRM_SETTINGS_PATH;
  39 /**
  40  *  Include class definitions
  41  */
  42 require_once 'PHPUnit/Extensions/Database/TestCase.php';
  43 require_once 'PHPUnit/Framework/TestResult.php';
  44 require_once 'PHPUnit/Extensions/Database/DataSet/FlatXmlDataSet.php';
  45 require_once 'PHPUnit/Extensions/Database/DataSet/XmlDataSet.php';
  46 require_once 'PHPUnit/Extensions/Database/DataSet/QueryDataSet.php';
  47 require_once 'tests/phpunit/Utils.php';
  48 require_once 'api/api.php';
  49 require_once 'CRM/Financial/BAO/FinancialType.php';
  50 define('API_LATEST_VERSION', 3);
  51
  52 /**
  53  *  Base class for CiviCRM unit tests
  54  *
  55  *  Common functions for unit tests
  56  * @package CiviCRM
  57  */
  58 class CiviUnitTestCase extends PHPUnit_Extensions_Database_TestCase {
  59
  60   /**
  61    * api version - easier to override than just a defin
  62    */
  63   protected $_apiversion = API_LATEST_VERSION;
  64   /**
  65    *  Database has been initialized
  66    *
  67    * @var boolean
  68    */
  69   private static $dbInit = FALSE;
  70
  71   /**
  72    *  Database connection
  73    *
  74    * @var PHPUnit_Extensions_Database_DB_IDatabaseConnection
  75    */
  76   protected $_dbconn;
  77
  78   /**
  79    * The database name
  80    *
  81    * @var string
  82    */
  83   static protected $_dbName;
  84
  85   /**
  86    * Track tables we have modified during a test
  87    */
  88   protected $_tablesToTruncate = array();
  89
  90   /**
  91    * @var array of temporary directory names
  92    */
  93   protected $tempDirs;
  94
  95   /**
  96    * @var Utils instance
  97    */
  98   public static $utils;
  99
 100   /**
 101    * @var boolean populateOnce allows to skip db resets in setUp
 102    *
 103    *  WARNING! USE WITH CAUTION - IT'LL RENDER DATA DEPENDENCIES
 104    *  BETWEEN TESTS WHEN RUN IN SUITE. SUITABLE FOR LOCAL, LIMITED
 105    *  "CHECK RUNS" ONLY!
 106    *
 107    *  IF POSSIBLE, USE $this->DBResetRequired = FALSE IN YOUR TEST CASE!
 108    *
 109    *  see also: http://forum.civicrm.org/index.php/topic,18065.0.html
 110    */
 111   public static $populateOnce = FALSE;
 112
 113   /**
 114    * Allow classes to state E-notice compliance
 115    */
 116   public $_eNoticeCompliant = TRUE;
 117
 118   /**
 119    * @var boolean DBResetRequired allows skipping DB reset
 120    *               in specific test case. If you still need
 121    *               to reset single test (method) of such case, call
 122    *               $this->cleanDB() in the first line of this
 123    *               test (method).
 124    */
 125   public $DBResetRequired = TRUE;
 126
 127   /**
 128    *  Constructor
 129    *
 130    *  Because we are overriding the parent class constructor, we
 131    *  need to show the same arguments as exist in the constructor of
 132    *  PHPUnit_Framework_TestCase, since
 133    *  PHPUnit_Framework_TestSuite::createTest() creates a
 134    *  ReflectionClass of the Test class and checks the constructor
 135    *  of that class to decide how to set up the test.
 136    *
 137    * @param  string $name
 138    * @param  array  $data
 139    * @param  string $dataName
 140    */
 141   function __construct($name = NULL, array$data = array(), $dataName = '') {
 142     parent::__construct($name, $data, $dataName);
 143
 144     // we need full error reporting
 145     error_reporting(E_ALL & ~E_NOTICE);
 146
 147     if (!empty($GLOBALS['mysql_db'])) {
 148       self::$_dbName = $GLOBALS['mysql_db'];
 149     }
 150     else {
 151       self::$_dbName = 'civicrm_tests_dev';
 152     }
 153
 154     //  create test database
 155     self::$utils = new Utils($GLOBALS['mysql_host'],
 156       $GLOBALS['mysql_port'],
 157       $GLOBALS['mysql_user'],
 158       $GLOBALS['mysql_pass']
 159     );
 160
 161     // also load the class loader
 162     require_once 'CRM/Core/ClassLoader.php';
 163     CRM_Core_ClassLoader::singleton()->register();
 164     if (function_exists('_civix_phpunit_setUp')) { // FIXME: loosen coupling
 165       _civix_phpunit_setUp();
 166     }
 167   }
 168
 169   /**
 170    * @return bool
 171    */
 172   function requireDBReset() {
 173     return $this->DBResetRequired;
 174   }
 175
 176   /**
 177    * @return string
 178    */
 179   static function getDBName() {
 180     $dbName = !empty($GLOBALS['mysql_db']) ? $GLOBALS['mysql_db'] : 'civicrm_tests_dev';
 181     return $dbName;
 182   }
 183
 184   /**
 185    *  Create database connection for this instance
 186    *
 187    *  Initialize the test database if it hasn't been initialized
 188    *
 189    * @return PHPUnit_Extensions_Database_DB_IDatabaseConnection connection
 190    */
 191   protected function getConnection() {
 192     $dbName = self::$_dbName;
 193     if (!self::$dbInit) {
 194       $dbName = self::getDBName();
 195
 196       //  install test database
 197       echo PHP_EOL . "Installing {$dbName} database" . PHP_EOL;
 198
 199       static::_populateDB(FALSE, $this);
 200
 201       self::$dbInit = TRUE;
 202     }
 203     return $this->createDefaultDBConnection(self::$utils->pdo, $dbName);
 204   }
 205
 206   /**
 207    *  Required implementation of abstract method
 208    */
 209   protected function getDataSet() {
 210   }
 211
 212   /**
 213    * @param bool $perClass
 214    * @param null $object
 215    * @return bool TRUE if the populate logic runs; FALSE if it is skipped
 216    */
 217   protected static function _populateDB($perClass = FALSE, &$object = NULL) {
 218
 219     if ($perClass || $object == NULL) {
 220       $dbreset = TRUE;
 221     }
 222     else {
 223       $dbreset = $object->requireDBReset();
 224     }
 225
 226     if (self::$populateOnce || !$dbreset) {
 227       return FALSE;
 228     }
 229     self::$populateOnce = NULL;
 230
 231     $dbName = self::getDBName();
 232     $pdo = self::$utils->pdo;
 233     // only consider real tables and not views
 234     $tables = $pdo->query("SELECT table_name FROM INFORMATION_SCHEMA.TABLES
 235     WHERE TABLE_SCHEMA = '{$dbName}' AND TABLE_TYPE = 'BASE TABLE'");
 236
 237     $truncates = array();
 238     $drops = array();
 239     foreach ($tables as $table) {
 240       // skip log tables
 241       if (substr($table['table_name'], 0, 4) == 'log_') {
 242         continue;
 243       }
 244
 245       // don't change list of installed extensions
 246       if ($table['table_name'] == 'civicrm_extension') {
 247         continue;
 248       }
 249
 250       if (substr($table['table_name'], 0, 14) == 'civicrm_value_') {
 251         $drops[] = 'DROP TABLE ' . $table['table_name'] . ';';
 252       }
 253       else {
 254         $truncates[] = 'TRUNCATE ' . $table['table_name'] . ';';
 255       }
 256     }
 257
 258     $queries = array(
 259       "USE {$dbName};",
 260       "SET foreign_key_checks = 0",
 261       // SQL mode needs to be strict, that's our standard
 262       "SET SQL_MODE='STRICT_ALL_TABLES';",
 263       "SET global innodb_flush_log_at_trx_commit = 2;",
 264     );
 265     $queries = array_merge($queries, $truncates);
 266     $queries = array_merge($queries, $drops);
 267     foreach ($queries as $query) {
 268       if (self::$utils->do_query($query) === FALSE) {
 269         //  failed to create test database
 270         echo "failed to create test db.";
 271         exit;
 272       }
 273     }
 274
 275     //  initialize test database
 276     $sql_file2 = dirname(dirname(dirname(dirname(__FILE__)))) . "/sql/civicrm_data.mysql";
 277     $sql_file3 = dirname(dirname(dirname(dirname(__FILE__)))) . "/sql/test_data.mysql";
 278     $sql_file4 = dirname(dirname(dirname(dirname(__FILE__)))) . "/sql/test_data_second_domain.mysql";
 279
 280     $query2 = file_get_contents($sql_file2);
 281     $query3 = file_get_contents($sql_file3);
 282     $query4 = file_get_contents($sql_file4);
 283     if (self::$utils->do_query($query2) === FALSE) {
 284       echo "Cannot load civicrm_data.mysql. Aborting.";
 285       exit;
 286     }
 287     if (self::$utils->do_query($query3) === FALSE) {
 288       echo "Cannot load test_data.mysql. Aborting.";
 289       exit;
 290     }
 291     if (self::$utils->do_query($query4) === FALSE) {
 292       echo "Cannot load test_data.mysql. Aborting.";
 293       exit;
 294     }
 295
 296     // done with all the loading, get transactions back
 297     if (self::$utils->do_query("set global innodb_flush_log_at_trx_commit = 1;") === FALSE) {
 298       echo "Cannot set global? Huh?";
 299       exit;
 300     }
 301
 302     if (self::$utils->do_query("SET foreign_key_checks = 1") === FALSE) {
 303       echo "Cannot get foreign keys back? Huh?";
 304       exit;
 305     }
 306
 307     unset($query, $query2, $query3);
 308
 309     // Rebuild triggers
 310     civicrm_api('system', 'flush', array('version' => 3, 'triggers' => 1));
 311
 312     return TRUE;
 313   }
 314
 315   public static function setUpBeforeClass() {
 316     static::_populateDB(TRUE);
 317
 318     // also set this global hack
 319     $GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK'] = array();
 320
 321     $env = new CRM_Utils_Check_Env();
 322     CRM_Utils_Check::singleton()->assertValid($env->checkMysqlTime());
 323   }
 324
 325   /**
 326    *  Common setup functions for all unit tests
 327    */
 328   protected function setUp() {
 329     CRM_Utils_Hook::singleton(TRUE);
 330     $this->errorScope = CRM_Core_TemporaryErrorScope::useException(); // REVERT
 331     //  Use a temporary file for STDIN
 332     $GLOBALS['stdin'] = tmpfile();
 333     if ($GLOBALS['stdin'] === FALSE) {
 334       echo "Couldn't open temporary file\n";
 335       exit(1);
 336     }
 337
 338     //  Get and save a connection to the database
 339     $this->_dbconn = $this->getConnection();
 340
 341     // reload database before each test
 342     //        $this->_populateDB();
 343
 344     // "initialize" CiviCRM to avoid problems when running single tests
 345     // FIXME: look at it closer in second stage
 346
 347     // initialize the object once db is loaded
 348     CRM_Core_Config::$_mail = NULL;
 349     $config = CRM_Core_Config::singleton();
 350
 351     // when running unit tests, use mockup user framework
 352     $config->setUserFramework('UnitTests');
 353
 354     // also fix the fatal error handler to throw exceptions,
 355     // rather than exit
 356     $config->fatalErrorHandler = 'CiviUnitTestCase_fatalErrorHandler';
 357
 358     // enable backtrace to get meaningful errors
 359     $config->backtrace = 1;
 360
 361     // disable any left-over test extensions
 362     CRM_Core_DAO::executeQuery('DELETE FROM civicrm_extension WHERE full_name LIKE "test.%"');
 363
 364     // reset all the caches
 365     CRM_Utils_System::flushCache();
 366
 367     // clear permissions stub to not check permissions
 368     $config = CRM_Core_Config::singleton();
 369     $config->userPermissionClass->permissions = NULL;
 370
 371     //flush component settings
 372     CRM_Core_Component::getEnabledComponents(TRUE);
 373
 374     if ($this->_eNoticeCompliant) {
 375       error_reporting(E_ALL);
 376     }
 377     else {
 378       error_reporting(E_ALL & ~E_NOTICE);
 379     }
 380   }
 381
 382   /**
 383    * Read everything from the datasets directory and insert into the db
 384    */
 385   public function loadAllFixtures() {
 386     $fixturesDir = __DIR__ . '/../../fixtures';
 387
 388     $this->getConnection()->getConnection()->query("SET FOREIGN_KEY_CHECKS = 0;");
 389
 390     $xmlFiles = glob($fixturesDir . '/*.xml');
 391     foreach ($xmlFiles as $xmlFixture) {
 392       $op = new PHPUnit_Extensions_Database_Operation_Insert();
 393       $dataset = new PHPUnit_Extensions_Database_DataSet_XMLDataSet($xmlFixture);
 394       $this->_tablesToTruncate = array_merge($this->_tablesToTruncate, $dataset->getTableNames());
 395       $op->execute($this->_dbconn, $dataset);
 396     }
 397
 398     $yamlFiles = glob($fixturesDir . '/*.yaml');
 399     foreach ($yamlFiles as $yamlFixture) {
 400       $op = new PHPUnit_Extensions_Database_Operation_Insert();
 401       $dataset = new PHPUnit_Extensions_Database_DataSet_YamlDataSet($yamlFixture);
 402       $this->_tablesToTruncate = array_merge($this->_tablesToTruncate, $dataset->getTableNames());
 403       $op->execute($this->_dbconn, $dataset);
 404     }
 405
 406     $this->getConnection()->getConnection()->query("SET FOREIGN_KEY_CHECKS = 1;");
 407   }
 408
 409   /**
 410    * emulate a logged in user since certain functions use that
 411    * value to store a record in the DB (like activity)
 412    * CRM-8180
 413    */
 414   public function createLoggedInUser() {
 415     $params = array(
 416       'first_name' => 'Logged In',
 417       'last_name' => 'User ' . rand(),
 418       'contact_type' => 'Individual',
 419     );
 420     $contactID = $this->individualCreate($params);
 421
 422     $session = CRM_Core_Session::singleton();
 423     $session->set('userID', $contactID);
 424   }
 425
 426   public function cleanDB() {
 427     self::$populateOnce = NULL;
 428     $this->DBResetRequired = TRUE;
 429
 430     $this->_dbconn = $this->getConnection();
 431     static::_populateDB();
 432     $this->tempDirs = array();
 433   }
 434
 435   /**
 436    *  Common teardown functions for all unit tests
 437    */
 438   protected function tearDown() {
 439     error_reporting(E_ALL & ~E_NOTICE);
 440     $tablesToTruncate = array('civicrm_contact');
 441     $this->quickCleanup($tablesToTruncate);
 442     $this->cleanTempDirs();
 443     $this->unsetExtensionSystem();
 444   }
 445
 446   /**
 447    *  FIXME: Maybe a better way to do it
 448    */
 449   function foreignKeyChecksOff() {
 450     self::$utils = new Utils($GLOBALS['mysql_host'],
 451       $GLOBALS['mysql_port'],
 452       $GLOBALS['mysql_user'],
 453       $GLOBALS['mysql_pass']
 454     );
 455     $dbName = self::getDBName();
 456     $query = "USE {$dbName};" . "SET foreign_key_checks = 1";
 457     if (self::$utils->do_query($query) === FALSE) {
 458       // fail happens
 459       echo 'Cannot set foreign_key_checks = 0';
 460       exit(1);
 461     }
 462     return TRUE;
 463   }
 464
 465   function foreignKeyChecksOn() {
 466     // FIXME: might not be needed if previous fixme implemented
 467   }
 468
 469   /**
 470    * Generic function to compare expected values after an api call to retrieved
 471    * DB values.
 472    *
 473    * @daoName  string   DAO Name of object we're evaluating.
 474    * @id       int      Id of object
 475    * @match    array    Associative array of field name => expected value. Empty if asserting
 476    *                      that a DELETE occurred
 477    * @delete   boolean  True if we're checking that a DELETE action occurred.
 478    */
 479   function assertDBState($daoName, $id, $match, $delete = FALSE) {
 480     if (empty($id)) {
 481       // adding this here since developers forget to check for an id
 482       // and hence we get the first value in the db
 483       $this->fail('ID not populated. Please fix your assertDBState usage!!!');
 484     }
 485
 486     $object = new $daoName();
 487     $object->id = $id;
 488     $verifiedCount = 0;
 489
 490     // If we're asserting successful record deletion, make sure object is NOT found.
 491     if ($delete) {
 492       if ($object->find(TRUE)) {
 493         $this->fail("Object not deleted by delete operation: $daoName, $id");
 494       }
 495       return;
 496     }
 497
 498     // Otherwise check matches of DAO field values against expected values in $match.
 499     if ($object->find(TRUE)) {
 500       $fields = & $object->fields();
 501       foreach ($fields as $name => $value) {
 502         $dbName = $value['name'];
 503         if (isset($match[$name])) {
 504           $verifiedCount++;
 505           $this->assertEquals($object->$dbName, $match[$name]);
 506         }
 507         elseif (isset($match[$dbName])) {
 508           $verifiedCount++;
 509           $this->assertEquals($object->$dbName, $match[$dbName]);
 510         }
 511       }
 512     }
 513     else {
 514       $this->fail("Could not retrieve object: $daoName, $id");
 515     }
 516     $object->free();
 517     $matchSize = count($match);
 518     if ($verifiedCount != $matchSize) {
 519       $this->fail("Did not verify all fields in match array: $daoName, $id. Verified count = $verifiedCount. Match array size = $matchSize");
 520     }
 521   }
 522
 523   // Request a record from the DB by seachColumn+searchValue. Success if a record is found.
 524   /**
 525    * @param $daoName
 526    * @param $searchValue
 527    * @param $returnColumn
 528    * @param $searchColumn
 529    * @param $message
 530    *
 531    * @return null|string
 532    * @throws PHPUnit_Framework_AssertionFailedError
 533    */
 534   function assertDBNotNull($daoName, $searchValue, $returnColumn, $searchColumn, $message) {
 535     if (empty($searchValue)) {
 536       $this->fail("empty value passed to assertDBNotNull");
 537     }
 538     $value = CRM_Core_DAO::getFieldValue($daoName, $searchValue, $returnColumn, $searchColumn, TRUE);
 539     $this->assertNotNull($value, $message);
 540
 541     return $value;
 542   }
 543
 544   // Request a record from the DB by seachColumn+searchValue. Success if returnColumn value is NULL.
 545   /**
 546    * @param $daoName
 547    * @param $searchValue
 548    * @param $returnColumn
 549    * @param $searchColumn
 550    * @param $message
 551    */
 552   function assertDBNull($daoName, $searchValue, $returnColumn, $searchColumn, $message) {
 553     $value = CRM_Core_DAO::getFieldValue($daoName, $searchValue, $returnColumn, $searchColumn, TRUE);
 554     $this->assertNull($value, $message);
 555   }
 556
 557   // Request a record from the DB by id. Success if row not found.
 558   /**
 559    * @param $daoName
 560    * @param $id
 561    * @param null $message
 562    */
 563   function assertDBRowNotExist($daoName, $id, $message = NULL) {
 564     $message = $message ? $message : "$daoName (#$id) should not exist";
 565     $value = CRM_Core_DAO::getFieldValue($daoName, $id, 'id', 'id', TRUE);
 566     $this->assertNull($value, $message);
 567   }
 568
 569   // Request a record from the DB by id. Success if row not found.
 570   /**
 571    * @param $daoName
 572    * @param $id
 573    * @param null $message
 574    */
 575   function assertDBRowExist($daoName, $id, $message = NULL) {
 576     $message = $message ? $message : "$daoName (#$id) should exist";
 577     $value = CRM_Core_DAO::getFieldValue($daoName, $id, 'id', 'id', TRUE);
 578     $this->assertEquals($id, $value, $message);
 579   }
 580
 581   // Compare a single column value in a retrieved DB record to an expected value
 582   /**
 583    * @param $daoName
 584    * @param $searchValue
 585    * @param $returnColumn
 586    * @param $searchColumn
 587    * @param $expectedValue
 588    * @param $message
 589    */
 590   function assertDBCompareValue($daoName, $searchValue, $returnColumn, $searchColumn,
 591                                 $expectedValue, $message
 592   ) {
 593     $value = CRM_Core_DAO::getFieldValue($daoName, $searchValue, $returnColumn, $searchColumn, TRUE);
 594     $this->assertEquals($value, $expectedValue, $message);
 595   }
 596
 597   // Compare all values in a single retrieved DB record to an array of expected values
 598   /**
 599    * @param $daoName
 600    * @param $searchParams
 601    * @param $expectedValues
 602    */
 603   function assertDBCompareValues($daoName, $searchParams, $expectedValues) {
 604     //get the values from db
 605     $dbValues = array();
 606     CRM_Core_DAO::commonRetrieve($daoName, $searchParams, $dbValues);
 607
 608     // compare db values with expected values
 609     self::assertAttributesEquals($expectedValues, $dbValues);
 610   }
 611
 612   /**
 613    * Assert that a SQL query returns a given value
 614    *
 615    * The first argument is an expected value. The remaining arguments are passed
 616    * to CRM_Core_DAO::singleValueQuery
 617    *
 618    * Example: $this->assertSql(2, 'select count(*) from foo where foo.bar like "%1"',
 619    * array(1 => array("Whiz", "String")));
 620    */
 621   function assertDBQuery($expected, $query, $params = array()) {
 622     $actual = CRM_Core_DAO::singleValueQuery($query, $params);
 623     $this->assertEquals($expected, $actual,
 624       sprintf('expected=[%s] actual=[%s] query=[%s]',
 625         $expected, $actual, CRM_Core_DAO::composeQuery($query, $params, FALSE)
 626       )
 627     );
 628   }
 629
 630   /**
 631    * Assert that two array-trees are exactly equal, notwithstanding
 632    * the sorting of keys
 633    *
 634    * @param array $expected
 635    * @param array $actual
 636    */
 637   function assertTreeEquals($expected, $actual) {
 638     $e = array();
 639     $a = array();
 640     CRM_Utils_Array::flatten($expected, $e, '', ':::');
 641     CRM_Utils_Array::flatten($actual, $a, '', ':::');
 642     ksort($e);
 643     ksort($a);
 644
 645     $this->assertEquals($e, $a);
 646   }
 647
 648   /**
 649    * Assert that two numbers are approximately equal
 650    *
 651    * @param int|float $expected
 652    * @param int|float $actual
 653    * @param int|float $tolerance
 654    * @param string $message
 655    */
 656   function assertApproxEquals($expected, $actual, $tolerance, $message = NULL) {
 657     if ($message === NULL) {
 658       $message = sprintf("approx-equals: expected=[%.3f] actual=[%.3f] tolerance=[%.3f]", $expected, $actual, $tolerance);
 659     }
 660     $this->assertTrue(abs($actual - $expected) < $tolerance, $message);
 661   }
 662
 663   /**
 664    * @param $expectedValues
 665    * @param $actualValues
 666    * @param null $message
 667    *
 668    * @throws PHPUnit_Framework_AssertionFailedError
 669    */
 670   function assertAttributesEquals($expectedValues, $actualValues, $message = NULL) {
 671     foreach ($expectedValues as $paramName => $paramValue) {
 672       if (isset($actualValues[$paramName])) {
 673         $this->assertEquals($paramValue, $actualValues[$paramName], "Value Mismatch On $paramName - value 1 is " . print_r($paramValue, TRUE) . "  value 2 is " . print_r($actualValues[$paramName], TRUE) );
 674       }
 675       else {
 676         $this->fail("Attribute '$paramName' not present in actual array.");
 677       }
 678     }
 679   }
 680
 681   /**
 682    * @param $key
 683    * @param $list
 684    */
 685   function assertArrayKeyExists($key, &$list) {
 686     $result = isset($list[$key]) ? TRUE : FALSE;
 687     $this->assertTrue($result, ts("%1 element exists?",
 688       array(1 => $key)
 689     ));
 690   }
 691
 692   /**
 693    * @param $key
 694    * @param $list
 695    */
 696   function assertArrayValueNotNull($key, &$list) {
 697     $this->assertArrayKeyExists($key, $list);
 698
 699     $value = isset($list[$key]) ? $list[$key] : NULL;
 700     $this->assertTrue($value,
 701       ts("%1 element not null?",
 702         array(1 => $key)
 703       )
 704     );
 705   }
 706
 707   /**
 708    * check that api returned 'is_error' => 0
 709    * else provide full message
 710    * @param array $apiResult api result
 711    * @param string $prefix extra test to add to message
 712    */
 713   function assertAPISuccess($apiResult, $prefix = '') {
 714     if (!empty($prefix)) {
 715       $prefix .= ': ';
 716     }
 717     $errorMessage = empty($apiResult['error_message']) ? '' : " " . $apiResult['error_message'];
 718
 719     if(!empty($apiResult['debug_information'])) {
 720       $errorMessage .= "\n " . print_r($apiResult['debug_information'], TRUE);
 721     }
 722     if(!empty($apiResult['trace'])){
 723       $errorMessage .= "\n" . print_r($apiResult['trace'], TRUE);
 724     }
 725     $this->assertEquals(0, $apiResult['is_error'], $prefix . $errorMessage);
 726   }
 727
 728   /**
 729    * check that api returned 'is_error' => 1
 730    * else provide full message
 731    *
 732    * @param array $apiResult api result
 733    * @param string $prefix extra test to add to message
 734    * @param null $expectedError
 735    */
 736   function assertAPIFailure($apiResult, $prefix = '', $expectedError = NULL) {
 737     if (!empty($prefix)) {
 738       $prefix .= ': ';
 739     }
 740     if($expectedError && !empty($apiResult['is_error'])){
 741       $this->assertEquals($expectedError, $apiResult['error_message'], 'api error message not as expected' . $prefix );
 742     }
 743     $this->assertEquals(1, $apiResult['is_error'], "api call should have failed but it succeeded " . $prefix . (print_r($apiResult, TRUE)));
 744     $this->assertNotEmpty($apiResult['error_message']);
 745   }
 746
 747   /**
 748    * @param $expected
 749    * @param $actual
 750    * @param string $message
 751    */
 752   function assertType($expected, $actual, $message = '') {
 753     return $this->assertInternalType($expected, $actual, $message);
 754   }
 755
 756   /**
 757    * check that a deleted item has been deleted
 758    */
 759   function assertAPIDeleted($entity, $id) {
 760     $this->callAPISuccess($entity, 'getcount', array('id' => $id), 0);
 761   }
 762
 763
 764   /**
 765    * check that api returned 'is_error' => 1
 766    * else provide full message
 767    * @param $result
 768    * @param $expected
 769    * @param array $valuesToExclude
 770    * @param string $prefix extra test to add to message
 771    * @internal param array $apiResult api result
 772    */
 773   function assertAPIArrayComparison($result, $expected, $valuesToExclude = array(), $prefix = '') {
 774     $valuesToExclude = array_merge($valuesToExclude, array('debug', 'xdebug', 'sequential'));
 775     foreach ($valuesToExclude as $value) {
 776       if(isset($result[$value])) {
 777         unset($result[$value]);
 778       }
 779       if(isset($expected[$value])) {
 780         unset($expected[$value]);
 781       }
 782     }
 783     $this->assertEquals($result, $expected, "api result array comparison failed " . $prefix . print_r($result, TRUE) . ' was compared to ' . print_r($expected, TRUE));
 784   }
 785
 786   /**
 787    * A stub for the API interface. This can be overriden by subclasses to change how the API is called.
 788    *
 789    * @param $entity
 790    * @param $action
 791    * @param $params
 792    * @return array|int
 793    */
 794   function civicrm_api($entity, $action, $params) {
 795     return civicrm_api($entity, $action, $params);
 796   }
 797
 798   /**
 799    * This function exists to wrap api functions
 800    * so we can ensure they succeed & throw exceptions without litterering the test with checks
 801    *
 802    * @param string $entity
 803    * @param string $action
 804    * @param array $params
 805    * @param mixed $checkAgainst optional value to check result against, implemented for getvalue,
 806    *   getcount, getsingle. Note that for getvalue the type is checked rather than the value
 807    *   for getsingle the array is compared against an array passed in - the id is not compared (for
 808    *   better or worse )
 809    *
 810    * @return array|int
 811    */
 812   function callAPISuccess($entity, $action, $params, $checkAgainst = NULL) {
 813     $params = array_merge(array(
 814         'version' => $this->_apiversion,
 815         'debug' => 1,
 816       ),
 817       $params
 818     );
 819     switch (strtolower($action)) {
 820       case 'getvalue' :
 821         return $this->callAPISuccessGetValue($entity, $params, $checkAgainst);
 822       case 'getsingle' :
 823         return $this->callAPISuccessGetSingle($entity, $params, $checkAgainst);
 824       case 'getcount' :
 825           return $this->callAPISuccessGetCount($entity, $params, $checkAgainst);
 826     }
 827     $result = $this->civicrm_api($entity, $action, $params);
 828     $this->assertAPISuccess($result, "Failure in api call for $entity $action");
 829     return $result;
 830   }
 831
 832   /**
 833    * This function exists to wrap api getValue function & check the result
 834    * so we can ensure they succeed & throw exceptions without litterering the test with checks
 835    * There is a type check in this
 836    *
 837    * @param string $entity
 838    * @param array $params
 839    * @param string $type - per http://php.net/manual/en/function.gettype.php possible types
 840    * - boolean
 841    * - integer
 842    * - double
 843    * - string
 844    * - array
 845    * - object
 846    *
 847    * @return array|int
 848    */
 849   function callAPISuccessGetValue($entity, $params, $type = NULL) {
 850     $params += array(
 851       'version' => $this->_apiversion,
 852       'debug' => 1,
 853     );
 854     $result = $this->civicrm_api($entity, 'getvalue', $params);
 855     if($type){
 856       if($type == 'integer'){
 857         // api seems to return integers as strings
 858         $this->assertTrue(is_numeric($result), "expected a numeric value but got " . print_r($result, 1));
 859       }
 860       else{
 861         $this->assertType($type, $result, "returned result should have been of type $type but was " );
 862       }
 863     }
 864     return $result;
 865   }
 866
 867   /**
 868    * This function exists to wrap api getsingle function & check the result
 869    * so we can ensure they succeed & throw exceptions without litterering the test with checks
 870    *
 871    * @param string $entity
 872    * @param array $params
 873    * @param array $checkAgainst - array to compare result against
 874    * - boolean
 875    * - integer
 876    * - double
 877    * - string
 878    * - array
 879    * - object
 880    *
 881    * @throws Exception
 882    * @return array|int
 883    */
 884   function callAPISuccessGetSingle($entity, $params, $checkAgainst = NULL) {
 885     $params += array(
 886       'version' => $this->_apiversion,
 887       'debug' => 1,
 888     );
 889     $result = $this->civicrm_api($entity, 'getsingle', $params);
 890     if(!is_array($result) || !empty($result['is_error']) || isset($result['values'])) {
 891       throw new Exception('Invalid getsingle result' . print_r($result, TRUE));
 892     }
 893     if($checkAgainst){
 894       // @todo - have gone with the fn that unsets id? should we check id?
 895       $this->checkArrayEquals($result, $checkAgainst);
 896     }
 897     return $result;
 898   }
 899
 900   /**
 901    * This function exists to wrap api getValue function & check the result
 902    * so we can ensure they succeed & throw exceptions without litterering the test with checks
 903    * There is a type check in this
 904    * @param string $entity
 905    * @param array $params
 906    * @param null $count
 907    * @throws Exception
 908    * @return array|int
 909    * @internal param string $type - per http://php.net/manual/en/function.gettype.php possible types
 910    * - boolean
 911    * - integer
 912    * - double
 913    * - string
 914    * - array
 915    * - object
 916    */
 917   function callAPISuccessGetCount($entity, $params, $count = NULL) {
 918     $params += array(
 919       'version' => $this->_apiversion,
 920       'debug' => 1,
 921     );
 922     $result = $this->civicrm_api($entity, 'getcount', $params);
 923     if(!is_integer($result) || !empty($result['is_error']) || isset($result['values'])) {
 924       throw new Exception('Invalid getcount result : ' . print_r($result, TRUE) . " type :" . gettype($result));
 925     }
 926     if(is_int($count)){
 927       $this->assertEquals($count, $result, "incorect count returned from $entity getcount");
 928     }
 929     return $result;
 930   }
 931
 932   /**
 933    * This function exists to wrap api functions
 934    * so we can ensure they succeed, generate and example & throw exceptions without litterering the test with checks
 935    *
 936    * @param string $entity
 937    * @param string $action
 938    * @param array $params
 939    * @param string $function - pass this in to create a generated example
 940    * @param string $file - pass this in to create a generated example
 941    * @param string $description
 942    * @param string|null $subfile
 943    * @param string|null $actionName
 944    * @return array|int
 945    */
 946   function callAPIAndDocument($entity, $action, $params, $function, $file, $description = "", $subfile = NULL, $actionName = NULL){
 947     $params['version'] = $this->_apiversion;
 948     $result = $this->callAPISuccess($entity, $action, $params);
 949     $this->documentMe($params, $result, $function, $file, $description, $subfile, $actionName);
 950     return $result;
 951   }
 952
 953   /**
 954    * This function exists to wrap api functions
 955    * so we can ensure they fail where expected & throw exceptions without litterering the test with checks
 956    * @param string $entity
 957    * @param string $action
 958    * @param array $params
 959    * @param string $expectedErrorMessage error
 960    * @param null $extraOutput
 961    * @return array|int
 962    */
 963   function callAPIFailure($entity, $action, $params, $expectedErrorMessage = NULL, $extraOutput = NULL) {
 964     if (is_array($params)) {
 965       $params += array(
 966         'version' => $this->_apiversion,
 967       );
 968     }
 969     $result = $this->civicrm_api($entity, $action, $params);
 970     $this->assertAPIFailure($result, "We expected a failure for $entity $action but got a success");
 971     return $result;
 972   }
 973
 974   /**
 975    * Create required data based on $this->entity & $this->params
 976    * This is just a way to set up the test data for delete & get functions
 977    * so the distinction between set
 978    * up & tested functions is clearer
 979    *
 980    *  @return array api Result
 981    */
 982   public function createTestEntity(){
 983     return $entity = $this->callAPISuccess($this->entity, 'create', $this->params);
 984   }
 985
 986   /**
 987    * Generic function to create Organisation, to be used in test cases
 988    *
 989    * @param array   parameters for civicrm_contact_add api function call
 990    *
 991    * @return int    id of Organisation created
 992    */
 993   function organizationCreate($params = array()) {
 994     if (!$params) {
 995       $params = array();
 996     }
 997     $orgParams = array(
 998       'organization_name' => 'Unit Test Organization',
 999       'contact_type' => 'Organization',
1000     );
1001     return $this->_contactCreate(array_merge($orgParams, $params));
1002   }
1003
1004   /**
1005    * Generic function to create Individual, to be used in test cases
1006    *
1007    * @param array   parameters for civicrm_contact_add api function call
1008    *
1009    * @return int    id of Individual created
1010    */
1011   function individualCreate($params = array()) {
1012     $params = array_merge(array(
1013         'first_name' => 'Anthony',
1014         'middle_name' => 'J.',
1015         'last_name' => 'Anderson',
1016         'prefix_id' => 3,
1017         'suffix_id' => 3,
1018         'email' => 'anthony_anderson@civicrm.org',
1019         'contact_type' => 'Individual',
1020       ), $params);
1021
1022     return $this->_contactCreate($params);
1023   }
1024
1025   /**
1026    * Generic function to create Household, to be used in test cases
1027    *
1028    * @param array   parameters for civicrm_contact_add api function call
1029    *
1030    * @return int    id of Household created
1031    */
1032   function householdCreate($params =  array()) {
1033     $params = array_merge(array(
1034         'household_name' => 'Unit Test household',
1035         'contact_type' => 'Household',
1036       ), $params);
1037     return $this->_contactCreate($params);
1038   }
1039
1040   /**
1041    * Private helper function for calling civicrm_contact_add
1042    *
1043    * @param $params
1044    *
1045    * @throws Exception
1046    * @internal param \parameters $array for civicrm_contact_add api function call
1047    *
1048    * @return int    id of Household created
1049    */
1050   private function _contactCreate($params) {
1051     $result = $this->callAPISuccess('contact', 'create', $params);
1052     if (!empty($result['is_error']) || empty($result['id'])) {
1053       throw new Exception('Could not create test contact, with message: ' . CRM_Utils_Array::value('error_message', $result) . "\nBacktrace:" . CRM_Utils_Array::value('trace', $result));
1054     }
1055     return $result['id'];
1056   }
1057
1058   /**
1059    * @param $contactID
1060    *
1061    * @return array|int
1062    */
1063   function contactDelete($contactID) {
1064     $params = array(
1065       'id' => $contactID,
1066       'skip_undelete' => 1,
1067       'debug' => 1,
1068     );
1069     $domain = new CRM_Core_BAO_Domain;
1070     $domain->contact_id = $contactID;
1071     if ($domain->find(TRUE)) {
1072       // we are finding tests trying to delete the domain contact in cleanup
1073       //since this is mainly for cleanup lets put a safeguard here
1074       return;
1075     }
1076     $result = $this->callAPISuccess('contact', 'delete', $params);
1077     return  $result;
1078   }
1079
1080   /**
1081    * @param $contactTypeId
1082    *
1083    * @throws Exception
1084    */
1085   function contactTypeDelete($contactTypeId) {
1086     require_once 'CRM/Contact/BAO/ContactType.php';
1087     $result = CRM_Contact_BAO_ContactType::del($contactTypeId);
1088     if (!$result) {
1089       throw new Exception('Could not delete contact type');
1090     }
1091   }
1092
1093   /**
1094    * @param array $params
1095    *
1096    * @return mixed
1097    */
1098   function membershipTypeCreate($params = array()) {
1099     CRM_Member_PseudoConstant::flush('membershipType');
1100     CRM_Core_Config::clearDBCache();
1101     $memberOfOrganization = $this->organizationCreate();
1102     $params = array_merge(array(
1103       'name' => 'General',
1104       'duration_unit' => 'year',
1105       'duration_interval' => 1,
1106       'period_type' => 'rolling',
1107       'member_of_contact_id' => $memberOfOrganization,
1108       'domain_id' => 1,
1109       'financial_type_id' => 1,
1110       'is_active' => 1,
1111       'sequential' => 1,
1112       'visibility' => 'Public',
1113     ), $params);
1114
1115     $result = $this->callAPISuccess('MembershipType', 'Create', $params);
1116
1117     CRM_Member_PseudoConstant::flush('membershipType');
1118     CRM_Utils_Cache::singleton()->flush();
1119
1120     return $result['id'];
1121   }
1122
1123   /**
1124    * @param $params
1125    *
1126    * @return mixed
1127    */
1128   function contactMembershipCreate($params) {
1129     $pre = array(
1130       'join_date' => '2007-01-21',
1131       'start_date' => '2007-01-21',
1132       'end_date' => '2007-12-21',
1133       'source' => 'Payment',
1134     );
1135
1136     foreach ($pre as $key => $val) {
1137       if (!isset($params[$key])) {
1138         $params[$key] = $val;
1139       }
1140     }
1141
1142     $result = $this->callAPISuccess('Membership', 'create', $params);
1143     return $result['id'];
1144   }
1145
1146   /**
1147    * Function to delete Membership Type
1148    *
1149    * @param $params
1150    * @internal param int $membershipTypeID
1151    */
1152   function membershipTypeDelete($params) {
1153     $result = $this->callAPISuccess('MembershipType', 'Delete', $params);
1154     return;
1155   }
1156
1157   /**
1158    * @param $membershipID
1159    */
1160   function membershipDelete($membershipID) {
1161     $deleteParams = array('id' => $membershipID);
1162     $result = $this->callAPISuccess('Membership', 'Delete', $deleteParams);
1163     return;
1164   }
1165
1166   /**
1167    * @param string $name
1168    *
1169    * @return mixed
1170    */
1171   function membershipStatusCreate($name = 'test member status') {
1172     $params['name'] = $name;
1173     $params['start_event'] = 'start_date';
1174     $params['end_event'] = 'end_date';
1175     $params['is_current_member'] = 1;
1176     $params['is_active'] = 1;
1177
1178     $result = $this->callAPISuccess('MembershipStatus', 'Create', $params);
1179     CRM_Member_PseudoConstant::flush('membershipStatus');
1180     return $result['id'];
1181   }
1182
1183   /**
1184    * @param $membershipStatusID
1185    */
1186   function membershipStatusDelete($membershipStatusID) {
1187     if (!$membershipStatusID) {
1188       return;
1189     }
1190     $result = $this->callAPISuccess('MembershipStatus', 'Delete', array('id' => $membershipStatusID));
1191     return;
1192   }
1193
1194   /**
1195    * @param array $params
1196    *
1197    * @return mixed
1198    */
1199   function relationshipTypeCreate($params = array()) {
1200     $params = array_merge(array(
1201         'name_a_b' => 'Relation 1 for relationship type create',
1202         'name_b_a' => 'Relation 2 for relationship type create',
1203         'contact_type_a' => 'Individual',
1204         'contact_type_b' => 'Organization',
1205         'is_reserved' => 1,
1206         'is_active' => 1,
1207       ),
1208        $params
1209     );
1210
1211     $result = $this->callAPISuccess('relationship_type', 'create', $params);
1212     CRM_Core_PseudoConstant::flush('relationshipType');
1213
1214     return $result['id'];
1215   }
1216
1217   /**
1218    * Function to delete Relatinship Type
1219    *
1220    * @param int $relationshipTypeID
1221    */
1222   function relationshipTypeDelete($relationshipTypeID) {
1223     $params['id'] = $relationshipTypeID;
1224     $this->callAPISuccess('relationship_type', 'delete', $params);
1225   }
1226
1227   /**
1228    * @param null $params
1229    *
1230    * @return mixed
1231    */
1232   function paymentProcessorTypeCreate($params = NULL) {
1233     if (is_null($params)) {
1234       $params = array(
1235         'name' => 'API_Test_PP',
1236         'title' => 'API Test Payment Processor',
1237         'class_name' => 'CRM_Core_Payment_APITest',
1238         'billing_mode' => 'form',
1239         'is_recur' => 0,
1240         'is_reserved' => 1,
1241         'is_active' => 1,
1242       );
1243     }
1244     $result = $this->callAPISuccess('payment_processor_type', 'create', $params);
1245
1246     CRM_Core_PseudoConstant::flush('paymentProcessorType');
1247
1248     return $result['id'];
1249   }
1250
1251   /**
1252    * Function to create Participant
1253    *
1254    * @param array $params  array of contact id and event id values
1255    *
1256    * @return int $id of participant created
1257    */
1258   function participantCreate($params) {
1259     if(empty($params['contact_id'])){
1260       $params['contact_id'] = $this->individualCreate();
1261     }
1262     if(empty($params['event_id'])){
1263       $event = $this->eventCreate();
1264       $params['event_id'] = $event['id'];
1265     }
1266     $defaults = array(
1267       'status_id' => 2,
1268       'role_id' => 1,
1269       'register_date' => 20070219,
1270       'source' => 'Wimbeldon',
1271       'event_level' => 'Payment',
1272       'debug' => 1,
1273     );
1274
1275     $params = array_merge($defaults, $params);
1276     $result = $this->callAPISuccess('Participant', 'create', $params);
1277     return $result['id'];
1278   }
1279
1280   /**
1281    * Function to create Payment Processor
1282    *
1283    * @return object of Payment Processsor
1284    */
1285   function processorCreate() {
1286     $processorParams = array(
1287       'domain_id' => 1,
1288       'name' => 'Dummy',
1289       'payment_processor_type_id' => 10,
1290       'financial_account_id' => 12,
1291       'is_active' => 1,
1292       'user_name' => '',
1293       'url_site' => 'http://dummy.com',
1294       'url_recur' => 'http://dummy.com',
1295       'billing_mode' => 1,
1296     );
1297     $paymentProcessor = CRM_Financial_BAO_PaymentProcessor::create($processorParams);
1298     return $paymentProcessor;
1299   }
1300
1301   /**
1302    * Function to create contribution page
1303    *
1304    * @param $params
1305    * @return object of contribution page
1306    */
1307   function contributionPageCreate($params) {
1308     $this->_pageParams = array(
1309       'title' => 'Test Contribution Page',
1310       'financial_type_id' => 1,
1311       'currency' => 'USD',
1312       'financial_account_id' => 1,
1313       'payment_processor' => $params['processor_id'],
1314       'is_active' => 1,
1315       'is_allow_other_amount' => 1,
1316       'min_amount' => 10,
1317       'max_amount' => 1000,
1318     );
1319     $contributionPage = $this->callAPISuccess('contribution_page', 'create', $this->_pageParams);
1320     return $contributionPage;
1321   }
1322
1323   /**
1324    * Function to create Tag
1325    *
1326    * @param array $params
1327    * @return array result of created tag
1328    */
1329   function tagCreate($params = array()) {
1330     $defaults = array(
1331       'name' => 'New Tag3',
1332       'description' => 'This is description for Our New Tag ',
1333       'domain_id' => '1',
1334     );
1335     $params = array_merge($defaults, $params);
1336     $result =  $this->callAPISuccess('Tag', 'create', $params);
1337     return $result['values'][$result['id']];
1338   }
1339
1340   /**
1341    * Function to delete Tag
1342    *
1343    * @param  int $tagId   id of the tag to be deleted
1344    */
1345   function tagDelete($tagId) {
1346     require_once 'api/api.php';
1347     $params = array(
1348       'tag_id' => $tagId,
1349     );
1350     $result = $this->callAPISuccess('Tag', 'delete', $params);
1351     return $result['id'];
1352   }
1353
1354   /**
1355    * Add entity(s) to the tag
1356    *
1357    * @param  array $params
1358    *
1359    * @return bool
1360    */
1361   function entityTagAdd($params) {
1362     $result = $this->callAPISuccess('entity_tag', 'create', $params);
1363     return TRUE;
1364   }
1365
1366   /**
1367    * Function to create contribution
1368    *
1369    * @param int $cID contact_id
1370    *
1371    * @internal param int $cTypeID id of financial type
1372    *
1373    * @return int id of created contribution
1374    */
1375   function pledgeCreate($cID) {
1376     $params = array(
1377       'contact_id' => $cID,
1378       'pledge_create_date' => date('Ymd'),
1379       'start_date' => date('Ymd'),
1380       'scheduled_date' => date('Ymd'),
1381       'amount' => 100.00,
1382       'pledge_status_id' => '2',
1383       'financial_type_id' => '1',
1384       'pledge_original_installment_amount' => 20,
1385       'frequency_interval' => 5,
1386       'frequency_unit' => 'year',
1387       'frequency_day' => 15,
1388       'installments' => 5,
1389     );
1390
1391     $result = $this->callAPISuccess('Pledge', 'create', $params);
1392     return $result['id'];
1393   }
1394
1395   /**
1396    * Function to delete contribution
1397    *
1398    * @param $pledgeId
1399    * @internal param int $contributionId
1400    */
1401   function pledgeDelete($pledgeId) {
1402     $params = array(
1403       'pledge_id' => $pledgeId,
1404     );
1405     $this->callAPISuccess('Pledge', 'delete', $params);
1406   }
1407
1408   /**
1409    * Function to create contribution
1410    *
1411    * @param int $cID contact_id
1412    * @param int $cTypeID id of financial type
1413    *
1414    * @param int $invoiceID
1415    * @param int $trxnID
1416    * @param int $paymentInstrumentID
1417    * @param bool $isFee
1418    * @return int id of created contribution
1419    */
1420   function contributionCreate($cID, $cTypeID = 1, $invoiceID = 67890, $trxnID = 12345, $paymentInstrumentID = 1, $isFee = TRUE) {
1421     $params = array(
1422       'domain_id' => 1,
1423       'contact_id' => $cID,
1424       'receive_date' => date('Ymd'),
1425       'total_amount' => 100.00,
1426       'financial_type_id' => empty($cTypeID) ? 1 : $cTypeID,
1427       'payment_instrument_id' => empty($paymentInstrumentID) ? 1 : $paymentInstrumentID,
1428       'non_deductible_amount' => 10.00,
1429       'trxn_id' => $trxnID,
1430       'invoice_id' => $invoiceID,
1431       'source' => 'SSF',
1432       'contribution_status_id' => 1,
1433       // 'note'                   => 'Donating for Nobel Cause', *Fixme
1434     );
1435
1436     if ($isFee) {
1437       $params['fee_amount'] = 5.00;
1438       $params['net_amount'] = 95.00;
1439     }
1440
1441     $result = $this->callAPISuccess('contribution', 'create', $params);
1442     return $result['id'];
1443   }
1444
1445   /**
1446    * Function to create online contribution
1447    *
1448    * @param $params
1449    * @param int $financialType id of financial type
1450    *
1451    * @param int $invoiceID
1452    * @param int $trxnID
1453    * @return int id of created contribution
1454    */
1455   function onlineContributionCreate($params, $financialType, $invoiceID = 67890, $trxnID = 12345) {
1456     $contribParams = array(
1457       'contact_id' => $params['contact_id'],
1458       'receive_date' => date('Ymd'),
1459       'total_amount' => 100.00,
1460       'financial_type_id' => $financialType,
1461       'contribution_page_id' => $params['contribution_page_id'],
1462       'trxn_id' => 12345,
1463       'invoice_id' => 67890,
1464       'source' => 'SSF',
1465     );
1466     $contribParams = array_merge($contribParams, $params);
1467     $result = $this->callAPISuccess('contribution', 'create', $contribParams);
1468
1469     return $result['id'];
1470   }
1471
1472   /**
1473    * Function to delete contribution
1474    *
1475    * @param int $contributionId
1476    *
1477    * @return array|int
1478    */
1479   function contributionDelete($contributionId) {
1480     $params = array(
1481       'contribution_id' => $contributionId,
1482     );
1483     $result = $this->callAPISuccess('contribution', 'delete', $params);
1484     return $result;
1485   }
1486
1487   /**
1488    * Function to create an Event
1489    *
1490    * @param array $params  name-value pair for an event
1491    *
1492    * @return array $event
1493    */
1494   function eventCreate($params = array()) {
1495     // if no contact was passed, make up a dummy event creator
1496     if (!isset($params['contact_id'])) {
1497       $params['contact_id'] = $this->_contactCreate(array(
1498         'contact_type' => 'Individual',
1499         'first_name' => 'Event',
1500         'last_name' => 'Creator',
1501       ));
1502     }
1503
1504     // set defaults for missing params
1505     $params = array_merge(array(
1506       'title' => 'Annual CiviCRM meet',
1507       'summary' => 'If you have any CiviCRM related issues or want to track where CiviCRM is heading, Sign up now',
1508       'description' => 'This event is intended to give brief idea about progess of CiviCRM and giving solutions to common user issues',
1509       'event_type_id' => 1,
1510       'is_public' => 1,
1511       'start_date' => 20081021,
1512       'end_date' => 20081023,
1513       'is_online_registration' => 1,
1514       'registration_start_date' => 20080601,
1515       'registration_end_date' => 20081015,
1516       'max_participants' => 100,
1517       'event_full_text' => 'Sorry! We are already full',
1518       'is_monetory' => 0,
1519       'is_active' => 1,
1520       'is_show_location' => 0,
1521     ), $params);
1522
1523     return $this->callAPISuccess('Event', 'create', $params);
1524   }
1525
1526   /**
1527    * Function to delete event
1528    *
1529    * @param int $id ID of the event
1530    *
1531    * @return array|int
1532    */
1533   function eventDelete($id) {
1534     $params = array(
1535       'event_id' => $id,
1536     );
1537     return $this->callAPISuccess('event', 'delete', $params);
1538   }
1539
1540   /**
1541    * Function to delete participant
1542    *
1543    * @param int $participantID
1544    *
1545    * @return array|int
1546    */
1547   function participantDelete($participantID) {
1548     $params = array(
1549       'id' => $participantID,
1550     );
1551     return $this->callAPISuccess('Participant', 'delete', $params);
1552   }
1553
1554   /**
1555    * Function to create participant payment
1556    *
1557    * @param $participantID
1558    * @param null $contributionID
1559    * @return int $id of created payment
1560    */
1561   function participantPaymentCreate($participantID, $contributionID = NULL) {
1562     //Create Participant Payment record With Values
1563     $params = array(
1564       'participant_id' => $participantID,
1565       'contribution_id' => $contributionID,
1566     );
1567
1568     $result = $this->callAPISuccess('participant_payment', 'create', $params);
1569     return $result['id'];
1570   }
1571
1572   /**
1573    * Function to delete participant payment
1574    *
1575    * @param int $paymentID
1576    */
1577   function participantPaymentDelete($paymentID) {
1578     $params = array(
1579       'id' => $paymentID,
1580     );
1581     $result = $this->callAPISuccess('participant_payment', 'delete', $params);
1582   }
1583
1584   /**
1585    * Function to add a Location
1586    *
1587    * @param $contactID
1588    * @return int location id of created location
1589    */
1590   function locationAdd($contactID) {
1591     $address = array(
1592       1 => array(
1593         'location_type' => 'New Location Type',
1594         'is_primary' => 1,
1595         'name' => 'Saint Helier St',
1596         'county' => 'Marin',
1597         'country' => 'United States',
1598         'state_province' => 'Michigan',
1599         'supplemental_address_1' => 'Hallmark Ct',
1600         'supplemental_address_2' => 'Jersey Village',
1601       )
1602     );
1603
1604     $params = array(
1605       'contact_id' => $contactID,
1606       'address' => $address,
1607       'location_format' => '2.0',
1608       'location_type' => 'New Location Type',
1609     );
1610
1611     $result = $this->callAPISuccess('Location', 'create', $params);
1612     return $result;
1613   }
1614
1615   /**
1616    * Function to delete Locations of contact
1617    *
1618    * @params array $pamars parameters
1619    */
1620   function locationDelete($params) {
1621     $result = $this->callAPISuccess('Location', 'delete', $params);
1622   }
1623
1624   /**
1625    * Function to add a Location Type
1626    *
1627    * @param null $params
1628    * @return int location id of created location
1629    */
1630   function locationTypeCreate($params = NULL) {
1631     if ($params === NULL) {
1632       $params = array(
1633         'name' => 'New Location Type',
1634         'vcard_name' => 'New Location Type',
1635         'description' => 'Location Type for Delete',
1636         'is_active' => 1,
1637       );
1638     }
1639
1640     $locationType = new CRM_Core_DAO_LocationType();
1641     $locationType->copyValues($params);
1642     $locationType->save();
1643     // clear getfields cache
1644     CRM_Core_PseudoConstant::flush();
1645     $this->callAPISuccess('phone', 'getfields', array('version' => 3, 'cache_clear' => 1));
1646     return $locationType;
1647   }
1648
1649   /**
1650    * Function to delete a Location Type
1651    *
1652    * @param int location type id
1653    */
1654   function locationTypeDelete($locationTypeId) {
1655     $locationType = new CRM_Core_DAO_LocationType();
1656     $locationType->id = $locationTypeId;
1657     $locationType->delete();
1658   }
1659
1660   /**
1661    * Function to add a Group
1662    *
1663    * @params array to add group
1664    *
1665    * @param array $params
1666    * @return int groupId of created group
1667    */
1668   function groupCreate($params = array()) {
1669     $params = array_merge(array(
1670         'name' => 'Test Group 1',
1671         'domain_id' => 1,
1672         'title' => 'New Test Group Created',
1673         'description' => 'New Test Group Created',
1674         'is_active' => 1,
1675         'visibility' => 'Public Pages',
1676         'group_type' => array(
1677           '1' => 1,
1678           '2' => 1,
1679         ),
1680       ), $params);
1681
1682     $result = $this->callAPISuccess('Group', 'create', $params);
1683     return $result['id'];
1684   }
1685
1686   /**
1687    * Function to delete a Group
1688    *
1689    * @param $gid
1690    * @internal param int $id
1691    */
1692   function groupDelete($gid) {
1693
1694     $params = array(
1695       'id' => $gid,
1696     );
1697
1698     $this->callAPISuccess('Group', 'delete', $params);
1699   }
1700
1701   /**
1702    * Create a UFField
1703    * @param array $params
1704    */
1705   function uFFieldCreate($params = array()) {
1706     $params = array_merge(array(
1707       'uf_group_id' => 1,
1708       'field_name' => 'first_name',
1709       'is_active' => 1,
1710       'is_required' => 1,
1711       'visibility' => 'Public Pages and Listings',
1712       'is_searchable' => '1',
1713       'label' => 'first_name',
1714       'field_type' => 'Individual',
1715       'weight' => 1,
1716     ), $params);
1717     $this->callAPISuccess('uf_field', 'create', $params);
1718   }
1719
1720   /**
1721    * Function to add a UF Join Entry
1722    *
1723    * @param null $params
1724    * @return int $id of created UF Join
1725    */
1726   function ufjoinCreate($params = NULL) {
1727     if ($params === NULL) {
1728       $params = array(
1729         'is_active' => 1,
1730         'module' => 'CiviEvent',
1731         'entity_table' => 'civicrm_event',
1732         'entity_id' => 3,
1733         'weight' => 1,
1734         'uf_group_id' => 1,
1735       );
1736     }
1737     $result = $this->callAPISuccess('uf_join', 'create', $params);
1738     return $result;
1739   }
1740
1741   /**
1742    * Function to delete a UF Join Entry
1743    *
1744    * @param array with missing uf_group_id
1745    */
1746   function ufjoinDelete($params = NULL) {
1747     if ($params === NULL) {
1748       $params = array(
1749         'is_active' => 1,
1750         'module' => 'CiviEvent',
1751         'entity_table' => 'civicrm_event',
1752         'entity_id' => 3,
1753         'weight' => 1,
1754         'uf_group_id' => '',
1755       );
1756     }
1757
1758     crm_add_uf_join($params);
1759   }
1760
1761   /**
1762    * Function to create Group for a contact
1763    *
1764    * @param int $contactId
1765    */
1766   function contactGroupCreate($contactId) {
1767     $params = array(
1768       'contact_id.1' => $contactId,
1769       'group_id' => 1,
1770     );
1771
1772     $this->callAPISuccess('GroupContact', 'Create', $params);
1773   }
1774
1775   /**
1776    * Function to delete Group for a contact
1777    *
1778    * @param $contactId
1779    * @internal param array $params
1780    */
1781   function contactGroupDelete($contactId) {
1782     $params = array(
1783       'contact_id.1' => $contactId,
1784       'group_id' => 1,
1785     );
1786     $this->civicrm_api('GroupContact', 'Delete', $params);
1787   }
1788
1789   /**
1790    * Function to create Activity
1791    *
1792    * @param null $params
1793    * @return array|int
1794    * @internal param int $contactId
1795    */
1796   function activityCreate($params = NULL) {
1797
1798     if ($params === NULL) {
1799       $individualSourceID = $this->individualCreate();
1800
1801       $contactParams = array(
1802         'first_name' => 'Julia',
1803         'Last_name' => 'Anderson',
1804         'prefix' => 'Ms.',
1805         'email' => 'julia_anderson@civicrm.org',
1806         'contact_type' => 'Individual',
1807       );
1808
1809       $individualTargetID = $this->individualCreate($contactParams);
1810
1811       $params = array(
1812         'source_contact_id' => $individualSourceID,
1813         'target_contact_id' => array($individualTargetID),
1814         'assignee_contact_id' => array($individualTargetID),
1815         'subject' => 'Discussion on warm beer',
1816         'activity_date_time' => date('Ymd'),
1817         'duration_hours' => 30,
1818         'duration_minutes' => 20,
1819         'location' => 'Baker Street',
1820         'details' => 'Lets schedule a meeting',
1821         'status_id' => 1,
1822         'activity_name' => 'Meeting',
1823       );
1824     }
1825
1826     $result = $this->callAPISuccess('Activity', 'create', $params);
1827
1828     $result['target_contact_id'] = $individualTargetID;
1829     $result['assignee_contact_id'] = $individualTargetID;
1830     return $result;
1831   }
1832
1833   /**
1834    * Function to create an activity type
1835    *
1836    * @params array $params parameters
1837    */
1838   function activityTypeCreate($params) {
1839     $result = $this->callAPISuccess('ActivityType', 'create', $params);
1840     return $result;
1841   }
1842
1843   /**
1844    * Function to delete activity type
1845    *
1846    * @params Integer $activityTypeId id of the activity type
1847    */
1848   function activityTypeDelete($activityTypeId) {
1849     $params['activity_type_id'] = $activityTypeId;
1850     $result = $this->callAPISuccess('ActivityType', 'delete', $params);
1851     return $result;
1852   }
1853
1854   /**
1855    * Function to create custom group
1856    *
1857    * @param array $params
1858    * @return array|int
1859    * @internal param string $className
1860    * @internal param string $title name of custom group
1861    */
1862   function customGroupCreate($params = array()) {
1863     $defaults = array(
1864       'title' => 'new custom group',
1865       'extends' => 'Contact',
1866       'domain_id' => 1,
1867       'style' => 'Inline',
1868       'is_active' => 1,
1869     );
1870
1871     $params = array_merge($defaults, $params);
1872
1873     if (strlen($params['title']) > 13) {
1874       $params['title'] =  substr($params['title'], 0, 13);
1875     }
1876
1877     //have a crack @ deleting it first in the hope this will prevent derailing our tests
1878     $check = $this->callAPISuccess('custom_group', 'get', array('title' => $params['title'], array('api.custom_group.delete' => 1)));
1879
1880     return $this->callAPISuccess('custom_group', 'create', $params);
1881   }
1882
1883   /**
1884    * existing function doesn't allow params to be over-ridden so need a new one
1885    * this one allows you to only pass in the params you want to change
1886    */
1887   function CustomGroupCreateByParams($params = array()) {
1888     $defaults = array(
1889       'title' => "API Custom Group",
1890       'extends' => 'Contact',
1891       'domain_id' => 1,
1892       'style' => 'Inline',
1893       'is_active' => 1,
1894     );
1895     $params = array_merge($defaults, $params);
1896     return $this->callAPISuccess('custom_group', 'create', $params);
1897   }
1898
1899   /**
1900    * Create custom group with multi fields
1901    */
1902   function CustomGroupMultipleCreateByParams($params = array()) {
1903     $defaults = array(
1904       'style' => 'Tab',
1905       'is_multiple' => 1,
1906     );
1907     $params = array_merge($defaults, $params);
1908     return $this->CustomGroupCreateByParams($params);
1909   }
1910
1911   /**
1912    * Create custom group with multi fields
1913    */
1914   function CustomGroupMultipleCreateWithFields($params = array()) {
1915     // also need to pass on $params['custom_field'] if not set but not in place yet
1916     $ids = array();
1917     $customGroup = $this->CustomGroupMultipleCreateByParams($params);
1918     $ids['custom_group_id'] = $customGroup['id'];
1919
1920     $customField = $this->customFieldCreate(array('custom_group_id' => $ids['custom_group_id'], 'label' => 'field_1' . $ids['custom_group_id']));
1921
1922     $ids['custom_field_id'][] = $customField['id'];
1923
1924     $customField = $this->customFieldCreate(array('custom_group_id' => $ids['custom_group_id'], 'default_value' => '', 'label' => 'field_2' . $ids['custom_group_id']));
1925     $ids['custom_field_id'][] = $customField['id'];
1926
1927     $customField = $this->customFieldCreate(array('custom_group_id' => $ids['custom_group_id'], 'default_value' => '', 'label' => 'field_3' . $ids['custom_group_id']));
1928     $ids['custom_field_id'][] = $customField['id'];
1929
1930     return $ids;
1931   }
1932
1933   /**
1934    * Create a custom group with a single text custom field.  See
1935    * participant:testCreateWithCustom for how to use this
1936    *
1937    * @param string $function __FUNCTION__
1938    * @param $filename
1939    * @internal param string $file __FILE__
1940    *
1941    * @return array $ids ids of created objects
1942    */
1943   function entityCustomGroupWithSingleFieldCreate($function, $filename) {
1944     $params = array('title' => $function);
1945     $entity = substr(basename($filename), 0, strlen(basename($filename)) - 8);
1946     $params['extends'] =  $entity ? $entity : 'Contact';
1947     $customGroup = $this->CustomGroupCreate($params);
1948     $customField = $this->customFieldCreate(array('custom_group_id' => $customGroup['id'], 'label' => $function));
1949     CRM_Core_PseudoConstant::flush();
1950
1951     return array('custom_group_id' => $customGroup['id'], 'custom_field_id' => $customField['id']);
1952   }
1953
1954   /**
1955    * Function to delete custom group
1956    *
1957    * @param int $customGroupID
1958    *
1959    * @return array|int
1960    */
1961   function customGroupDelete($customGroupID) {
1962     $params['id'] = $customGroupID;
1963     return $this->callAPISuccess('custom_group', 'delete', $params);
1964   }
1965
1966   /**
1967    * Function to create custom field
1968    *
1969    * @param array $params (custom_group_id) is required
1970    * @return array|int
1971    * @internal param string $name name of custom field
1972    * @internal param int $apiversion API  version to use
1973    */
1974   function customFieldCreate($params) {
1975     $params = array_merge(array(
1976       'label' => 'Custom Field',
1977       'data_type' => 'String',
1978       'html_type' => 'Text',
1979       'is_searchable' => 1,
1980       'is_active' => 1,
1981       'default_value' => 'defaultValue',
1982     ), $params);
1983
1984     $result = $this->callAPISuccess('custom_field', 'create', $params);
1985
1986     if ($result['is_error'] == 0 && isset($result['id'])) {
1987       CRM_Core_BAO_CustomField::getTableColumnGroup($result['id'], 1);
1988       // force reset of enabled components to help grab custom fields
1989       CRM_Core_Component::getEnabledComponents(1);
1990       return $result;
1991     }
1992   }
1993
1994   /**
1995    * Function to delete custom field
1996    *
1997    * @param int $customFieldID
1998    *
1999    * @return array|int
2000    */
2001   function customFieldDelete($customFieldID) {
2002
2003     $params['id'] = $customFieldID;
2004     return $this->callAPISuccess('custom_field', 'delete', $params);
2005   }
2006
2007   /**
2008    * Function to create note
2009    *
2010    * @params array $params  name-value pair for an event
2011    *
2012    * @param $cId
2013    * @return array $note
2014    */
2015   function noteCreate($cId) {
2016     $params = array(
2017       'entity_table' => 'civicrm_contact',
2018       'entity_id' => $cId,
2019       'note' => 'hello I am testing Note',
2020       'contact_id' => $cId,
2021       'modified_date' => date('Ymd'),
2022       'subject' => 'Test Note',
2023     );
2024
2025     return $this->callAPISuccess('Note', 'create', $params);
2026   }
2027
2028   /**
2029    * Enable CiviCampaign Component
2030    */
2031   function enableCiviCampaign() {
2032     CRM_Core_BAO_ConfigSetting::enableComponent('CiviCampaign');
2033     // force reload of config object
2034     $config = CRM_Core_Config::singleton(TRUE, TRUE);
2035     //flush cache by calling with reset
2036     $activityTypes = CRM_Core_PseudoConstant::activityType(TRUE, TRUE, TRUE, 'name', TRUE);
2037   }
2038
2039   /**
2040    * Create test generated example in api/v3/examples.
2041    * To turn this off (e.g. on the server) set
2042    * define(DONT_DOCUMENT_TEST_CONFIG ,1);
2043    * in your settings file
2044    * @param array $params array as passed to civicrm_api function
2045    * @param array $result array as received from the civicrm_api function
2046    * @param string $function calling function - generally __FUNCTION__
2047    * @param string $filename called from file - generally __FILE__
2048    * @param string $description descriptive text for the example file
2049    * @param string $subfile name for subfile - if this is completed the example will be put in a subfolder (named by the entity)
2050    * @param string $action - optional action - otherwise taken from function name
2051    */
2052   function documentMe($params, $result, $function, $filename, $description = "", $subfile = NULL, $action = NULL) {
2053     if (defined('DONT_DOCUMENT_TEST_CONFIG')) {
2054       return;
2055     }
2056     $entity = substr(basename($filename), 0, strlen(basename($filename)) - 8);
2057     //todo - this is a bit cludgey
2058     if (empty($action)) {
2059       if (strstr($function, 'Create')) {
2060         $action = empty($action) ? 'create' : $action;
2061         $entityAction = 'Create';
2062       }
2063       elseif (strstr($function, 'GetSingle')) {
2064         $action = empty($action) ? 'getsingle' : $action;
2065         $entityAction = 'GetSingle';
2066       }
2067       elseif (strstr($function, 'GetValue')) {
2068         $action = empty($action) ? 'getvalue' : $action;
2069         $entityAction = 'GetValue';
2070       }
2071       elseif (strstr($function, 'GetCount')) {
2072         $action = empty($action) ? 'getcount' : $action;
2073         $entityAction = 'GetCount';
2074       }
2075       elseif (strstr($function, 'GetFields')) {
2076         $action = empty($action) ? 'getfields' : $action;
2077         $entityAction = 'GetFields';
2078       }
2079       elseif (strstr($function, 'GetList')) {
2080         $action = empty($action) ? 'getlist' : $action;
2081         $entityAction = 'GetList';
2082       }
2083       elseif (strstr($function, 'Get')) {
2084         $action = empty($action) ? 'get' : $action;
2085         $entityAction = 'Get';
2086       }
2087       elseif (strstr($function, 'Delete')) {
2088         $action = empty($action) ? 'delete' : $action;
2089         $entityAction = 'Delete';
2090       }
2091       elseif (strstr($function, 'Update')) {
2092         $action = empty($action) ? 'update' : $action;
2093         $entityAction = 'Update';
2094       }
2095       elseif (strstr($function, 'Subscribe')) {
2096         $action = empty($action) ? 'subscribe' : $action;
2097         $entityAction = 'Subscribe';
2098       }
2099       elseif (strstr($function, 'Submit')) {
2100         $action = empty($action) ? 'submit' : $action;
2101         $entityAction = 'Submit';
2102       }
2103       elseif (strstr($function, 'Apply')) {
2104         $action = empty($action) ? 'apply' : $action;
2105         $entityAction = 'Apply';
2106       }
2107       elseif (strstr($function, 'Replace')) {
2108         $action = empty($action) ? 'replace' : $action;
2109         $entityAction = 'Replace';
2110       }
2111     }
2112     else {
2113       $entityAction = ucwords($action);
2114     }
2115
2116     $this->tidyExampleResult($result);
2117     if(isset($params['version'])) {
2118       unset($params['version']);
2119     }
2120     // a cleverer person than me would do it in a single regex
2121     if (strstr($entity, 'UF')) {
2122       $fnPrefix = strtolower(preg_replace('/(?<! )(?<!^)(?<=UF)[A-Z]/', '_$0', $entity));
2123     }
2124     else {
2125       $fnPrefix = strtolower(preg_replace('/(?<! )(?<!^)[A-Z]/', '_$0', $entity));
2126     }
2127     $smarty = CRM_Core_Smarty::singleton();
2128     $smarty->assign('testfunction', $function);
2129     $function = $fnPrefix . "_" . strtolower($action);
2130     $smarty->assign('function', $function);
2131     $smarty->assign('fnPrefix', $fnPrefix);
2132     $smarty->assign('params', $params);
2133     $smarty->assign('entity', $entity);
2134     $smarty->assign('filename', basename($filename));
2135     $smarty->assign('description', $description);
2136     $smarty->assign('result', $result);
2137
2138     $smarty->assign('action', $action);
2139     if (empty($subfile)) {
2140       $subfile = $entityAction;
2141     }
2142     if (file_exists('../tests/templates/documentFunction.tpl')) {
2143       if (!is_dir("../api/v3/examples/$entity")) {
2144         mkdir("../api/v3/examples/$entity");
2145       }
2146       $f = fopen("../api/v3/examples/$entity/$subfile.php", "w+b");
2147       fwrite($f, $smarty->fetch('../tests/templates/documentFunction.tpl'));
2148       fclose($f);
2149     }
2150   }
2151
2152   /**
2153    * Tidy up examples array so that fields that change often ..don't
2154    * and debug related fields are unset
2155    *
2156    * @param $result
2157    *
2158    * @internal param array $params
2159    */
2160   function tidyExampleResult(&$result){
2161     if(!is_array($result)) {
2162       return;
2163     }
2164     $fieldsToChange = array(
2165       'hash' => '67eac7789eaee00',
2166       'modified_date' => '2012-11-14 16:02:35',
2167       'created_date' => '2013-07-28 08:49:19',
2168       'create_date' => '20120130621222105',
2169       'application_received_date' => '20130728084957',
2170       'in_date' => '2013-07-28 08:50:19',
2171       'scheduled_date' => '20130728085413',
2172       'approval_date' => '20130728085413',
2173       'pledge_start_date_high' => '20130726090416',
2174       'start_date' => '2013-07-29 00:00:00',
2175       'event_start_date' => '2013-07-29 00:00:00',
2176       'end_date' => '2013-08-04 00:00:00',
2177       'event_end_date' => '2013-08-04 00:00:00',
2178       'decision_date' => '20130805000000',
2179     );
2180
2181     $keysToUnset = array('xdebug', 'undefined_fields',);
2182     foreach ($keysToUnset as $unwantedKey) {
2183       if(isset($result[$unwantedKey])) {
2184         unset($result[$unwantedKey]);
2185       }
2186     }
2187     if (isset($result['values'])) {
2188       if(!is_array($result['values'])) {
2189         return;
2190       }
2191       $resultArray = &$result['values'];
2192     }
2193     elseif(is_array($result)) {
2194       $resultArray = &$result;
2195     }
2196     else {
2197       return;
2198     }
2199
2200     foreach ($resultArray as $index => &$values) {
2201         if(!is_array($values)) {
2202           continue;
2203         }
2204         foreach($values as $key => &$value) {
2205           if(substr($key, 0, 3)  == 'api' && is_array($value)) {
2206             if(isset($value['is_error'])) {
2207               // we have a std nested result format
2208               $this->tidyExampleResult($value);
2209             }
2210             else{
2211               foreach ($value as &$nestedResult) {
2212                 // this is an alternative syntax for nested results a keyed array of results
2213                 $this->tidyExampleResult($nestedResult);
2214               }
2215             }
2216           }
2217           if(in_array($key, $keysToUnset)) {
2218             unset($values[$key]);
2219             break;
2220           }
2221           if(array_key_exists($key, $fieldsToChange) && !empty($value)) {
2222             $value = $fieldsToChange[$key];
2223           }
2224           if(is_string($value)) {
2225             $value =  addslashes($value);
2226           }
2227         }
2228     }
2229   }
2230
2231   /**
2232    * Function to delete note
2233    *
2234    * @params int $noteID
2235    *
2236    */
2237   function noteDelete($params) {
2238     return $this->callAPISuccess('Note', 'delete', $params);
2239   }
2240
2241   /**
2242    * Function to create custom field with Option Values
2243    *
2244    * @param array $customGroup
2245    * @param string $name name of custom field
2246    *
2247    * @return array|int
2248    */
2249   function customFieldOptionValueCreate($customGroup, $name) {
2250     $fieldParams = array(
2251       'custom_group_id' => $customGroup['id'],
2252       'name' => 'test_custom_group',
2253       'label' => 'Country',
2254       'html_type' => 'Select',
2255       'data_type' => 'String',
2256       'weight' => 4,
2257       'is_required' => 1,
2258       'is_searchable' => 0,
2259       'is_active' => 1,
2260     );
2261
2262     $optionGroup = array(
2263       'domain_id' => 1,
2264       'name' => 'option_group1',
2265       'label' => 'option_group_label1',
2266     );
2267
2268     $optionValue = array(
2269       'option_label' => array('Label1', 'Label2'),
2270       'option_value' => array('value1', 'value2'),
2271       'option_name' => array($name . '_1', $name . '_2'),
2272       'option_weight' => array(1, 2),
2273       'option_status' => 1,
2274     );
2275
2276     $params = array_merge($fieldParams, $optionGroup, $optionValue);
2277
2278     return $this->callAPISuccess('custom_field', 'create', $params);
2279   }
2280
2281   /**
2282    * @param $entities
2283    *
2284    * @return bool
2285    */
2286   function confirmEntitiesDeleted($entities) {
2287     foreach ($entities as $entity) {
2288
2289       $result = $this->callAPISuccess($entity, 'Get', array());
2290       if ($result['error'] == 1 || $result['count'] > 0) {
2291         // > than $entity[0] to allow a value to be passed in? e.g. domain?
2292         return TRUE;
2293       }
2294     }
2295   }
2296
2297   /**
2298    * @param $tablesToTruncate
2299    * @param bool $dropCustomValueTables
2300    */
2301   function quickCleanup($tablesToTruncate, $dropCustomValueTables = FALSE) {
2302     if ($dropCustomValueTables) {
2303       $tablesToTruncate[] = 'civicrm_custom_group';
2304       $tablesToTruncate[] = 'civicrm_custom_field';
2305     }
2306
2307     $tablesToTruncate = array_unique(array_merge($this->_tablesToTruncate, $tablesToTruncate));
2308
2309     CRM_Core_DAO::executeQuery("SET FOREIGN_KEY_CHECKS = 0;");
2310     foreach ($tablesToTruncate as $table) {
2311       $sql = "TRUNCATE TABLE $table";
2312       CRM_Core_DAO::executeQuery($sql);
2313     }
2314     CRM_Core_DAO::executeQuery("SET FOREIGN_KEY_CHECKS = 1;");
2315
2316     if ($dropCustomValueTables) {
2317       $dbName = self::getDBName();
2318       $query = "
2319 SELECT TABLE_NAME as tableName
2320 FROM   INFORMATION_SCHEMA.TABLES
2321 WHERE  TABLE_SCHEMA = '{$dbName}'
2322 AND    ( TABLE_NAME LIKE 'civicrm_value_%' )
2323 ";
2324
2325       $tableDAO = CRM_Core_DAO::executeQuery($query);
2326       while ($tableDAO->fetch()) {
2327         $sql = "DROP TABLE {$tableDAO->tableName}";
2328         CRM_Core_DAO::executeQuery($sql);
2329       }
2330     }
2331   }
2332
2333   /**
2334    * Clean up financial entities after financial tests (so we remember to get all the tables :-))
2335    */
2336   function quickCleanUpFinancialEntities() {
2337     $tablesToTruncate = array(
2338       'civicrm_contribution',
2339       'civicrm_financial_trxn',
2340       'civicrm_contribution_recur',
2341       'civicrm_line_item',
2342       'civicrm_contribution_page',
2343       'civicrm_payment_processor',
2344       'civicrm_entity_financial_trxn',
2345       'civicrm_membership',
2346       'civicrm_membership_type',
2347       'civicrm_membership_payment',
2348       'civicrm_membership_status',
2349       'civicrm_event',
2350       'civicrm_participant',
2351       'civicrm_participant_payment',
2352       'civicrm_pledge',
2353     );
2354     $this->quickCleanup($tablesToTruncate);
2355   }
2356   /*
2357    * Function does a 'Get' on the entity & compares the fields in the Params with those returned
2358    * Default behaviour is to also delete the entity
2359    * @param array $params params array to check agains
2360    * @param int  $id id of the entity concerned
2361    * @param string $entity name of entity concerned (e.g. membership)
2362    * @param bool $delete should the entity be deleted as part of this check
2363    * @param string $errorText text to print on error
2364    *
2365    */
2366   /**
2367    * @param $params
2368    * @param $id
2369    * @param $entity
2370    * @param int $delete
2371    * @param string $errorText
2372    *
2373    * @throws Exception
2374    */
2375   function getAndCheck($params, $id, $entity, $delete = 1, $errorText = '') {
2376
2377     $result = $this->callAPISuccessGetSingle($entity, array(
2378       'id' => $id,
2379     ));
2380
2381     if ($delete) {
2382       $this->callAPISuccess($entity, 'Delete', array(
2383         'id' => $id,
2384       ));
2385     }
2386     $dateFields = $keys = $dateTimeFields = array();
2387     $fields = $this->callAPISuccess($entity, 'getfields', array('version' => 3, 'action' => 'get'));
2388     foreach ($fields['values'] as $field => $settings) {
2389       if (array_key_exists($field, $result)) {
2390         $keys[CRM_Utils_Array::Value('name', $settings, $field)] = $field;
2391       }
2392       else {
2393         $keys[CRM_Utils_Array::Value('name', $settings, $field)] = CRM_Utils_Array::value('name', $settings, $field);
2394       }
2395       $type = CRM_Utils_Array::value('type', $settings);
2396       if ($type == CRM_Utils_Type::T_DATE) {
2397         $dateFields[] = $settings['name'];
2398         // we should identify both real names & unique names as dates
2399         if($field != $settings['name']) {
2400           $dateFields[] = $field;
2401         }
2402       }
2403       if($type == CRM_Utils_Type::T_DATE + CRM_Utils_Type::T_TIME) {
2404         $dateTimeFields[] = $settings['name'];
2405         // we should identify both real names & unique names as dates
2406         if($field != $settings['name']) {
2407           $dateTimeFields[] = $field;
2408         }
2409       }
2410     }
2411
2412     if (strtolower($entity) == 'contribution') {
2413       $params['receive_date'] = date('Y-m-d', strtotime($params['receive_date']));
2414       // this is not returned in id format
2415       unset($params['payment_instrument_id']);
2416       $params['contribution_source'] = $params['source'];
2417       unset($params['source']);
2418     }
2419
2420     foreach ($params as $key => $value) {
2421       if ($key == 'version' || substr($key, 0, 3) == 'api' || !array_key_exists($keys[$key], $result)) {
2422         continue;
2423       }
2424       if (in_array($key, $dateFields)) {
2425         $value = date('Y-m-d', strtotime($value));
2426         $result[$key] = date('Y-m-d', strtotime($result[$key]));
2427       }
2428       if (in_array($key, $dateTimeFields)) {
2429         $value = date('Y-m-d H:i:s', strtotime($value));
2430         $result[$keys[$key]] = date('Y-m-d H:i:s', strtotime(CRM_Utils_Array::value($keys[$key], $result, CRM_Utils_Array::value($key, $result))));
2431       }
2432       $this->assertEquals($value, $result[$keys[$key]], $key . " GetandCheck function determines that for key {$key} value: $value doesn't match " . print_r($result[$keys[$key]], TRUE) . $errorText);
2433     }
2434   }
2435
2436   /**
2437    * Function to get formatted values in  the actual and expected result
2438    * @param array $actual actual calculated values
2439    * @param array $expected expected values
2440    *
2441    */
2442   function checkArrayEquals(&$actual, &$expected) {
2443     self::unsetId($actual);
2444     self::unsetId($expected);
2445     $this->assertEquals($actual, $expected);
2446   }
2447
2448   /**
2449    * Function to unset the key 'id' from the array
2450    * @param array $unformattedArray The array from which the 'id' has to be unset
2451    *
2452    */
2453   static function unsetId(&$unformattedArray) {
2454     $formattedArray = array();
2455     if (array_key_exists('id', $unformattedArray)) {
2456       unset($unformattedArray['id']);
2457     }
2458     if (!empty($unformattedArray['values']) && is_array($unformattedArray['values'])) {
2459       foreach ($unformattedArray['values'] as $key => $value) {
2460         if (is_Array($value)) {
2461           foreach ($value as $k => $v) {
2462             if ($k == 'id') {
2463               unset($value[$k]);
2464             }
2465           }
2466         }
2467         elseif ($key == 'id') {
2468           $unformattedArray[$key];
2469         }
2470         $formattedArray = array($value);
2471       }
2472       $unformattedArray['values'] = $formattedArray;
2473     }
2474   }
2475
2476   /**
2477    *  Helper to enable/disable custom directory support
2478    *
2479    * @param array $customDirs with members:
2480    *   'php_path' Set to TRUE to use the default, FALSE or "" to disable support, or a string path to use another path
2481    *   'template_path' Set to TRUE to use the default, FALSE or "" to disable support, or a string path to use another path
2482    */
2483   function customDirectories($customDirs) {
2484     require_once 'CRM/Core/Config.php';
2485     $config = CRM_Core_Config::singleton();
2486
2487     if (empty($customDirs['php_path']) || $customDirs['php_path'] === FALSE) {
2488       unset($config->customPHPPathDir);
2489     }
2490     elseif ($customDirs['php_path'] === TRUE) {
2491       $config->customPHPPathDir = dirname(dirname(__FILE__)) . '/custom_directories/php/';
2492     }
2493     else {
2494       $config->customPHPPathDir = $php_path;
2495     }
2496
2497     if (empty($customDirs['template_path']) || $customDirs['template_path'] === FALSE) {
2498       unset($config->customTemplateDir);
2499     }
2500     elseif ($customDirs['template_path'] === TRUE) {
2501       $config->customTemplateDir = dirname(dirname(__FILE__)) . '/custom_directories/templates/';
2502     }
2503     else {
2504       $config->customTemplateDir = $template_path;
2505     }
2506   }
2507
2508   /**
2509    * Generate a temporary folder
2510    *
2511    * @param string $prefix
2512    * @return string $string
2513    */
2514   function createTempDir($prefix = 'test-') {
2515     $tempDir = CRM_Utils_File::tempdir($prefix);
2516     $this->tempDirs[] = $tempDir;
2517     return $tempDir;
2518   }
2519
2520   function cleanTempDirs() {
2521     if (!is_array($this->tempDirs)) {
2522       // fix test errors where this is not set
2523       return;
2524     }
2525     foreach ($this->tempDirs as $tempDir) {
2526       if (is_dir($tempDir)) {
2527         CRM_Utils_File::cleanDir($tempDir, TRUE, FALSE);
2528       }
2529     }
2530   }
2531
2532   /**
2533    * Temporarily replace the singleton extension with a different one
2534    */
2535   function setExtensionSystem(CRM_Extension_System $system) {
2536     if ($this->origExtensionSystem == NULL) {
2537       $this->origExtensionSystem = CRM_Extension_System::singleton();
2538     }
2539     CRM_Extension_System::setSingleton($this->origExtensionSystem);
2540   }
2541
2542   function unsetExtensionSystem() {
2543     if ($this->origExtensionSystem !== NULL) {
2544       CRM_Extension_System::setSingleton($this->origExtensionSystem);
2545       $this->origExtensionSystem = NULL;
2546     }
2547   }
2548
2549   /**
2550    * Temporarily alter the settings-metadata to add a mock setting.
2551    *
2552    * WARNING: The setting metadata will disappear on the next cache-clear.
2553    *
2554    * @param $extras
2555    * @return void
2556    */
2557   function setMockSettingsMetaData($extras) {
2558     CRM_Core_BAO_Setting::$_cache = array();
2559     $this->callAPISuccess('system','flush', array());
2560     CRM_Core_BAO_Setting::$_cache = array();
2561
2562     CRM_Utils_Hook::singleton()->setHook('civicrm_alterSettingsMetaData', function (&$metadata, $domainId, $profile) use ($extras) {
2563       $metadata = array_merge($metadata, $extras);
2564     });
2565
2566     $fields = $this->callAPISuccess('setting', 'getfields', array());
2567     foreach ($extras as $key => $spec) {
2568       $this->assertNotEmpty($spec['title']);
2569       $this->assertEquals($spec['title'], $fields['values'][$key]['title']);
2570     }
2571   }
2572
2573   /**
2574    * @param $name
2575    */
2576   function financialAccountDelete($name) {
2577     $financialAccount = new CRM_Financial_DAO_FinancialAccount();
2578     $financialAccount->name = $name;
2579     if($financialAccount->find(TRUE)) {
2580       $entityFinancialType = new CRM_Financial_DAO_EntityFinancialAccount();
2581       $entityFinancialType->financial_account_id = $financialAccount->id;
2582       $entityFinancialType->delete();
2583       $financialAccount->delete();
2584     }
2585   }
2586
2587   /**
2588    * Use $ids as an instruction to do test cleanup
2589    */
2590   function deleteFromIDSArray() {
2591     foreach ($this->ids as $entity => $ids) {
2592       foreach ($ids as $id) {
2593         $this->callAPISuccess($entity, 'delete', array('id' => $id));
2594       }
2595     }
2596   }
2597
2598   /**
2599    * FIXME: something NULLs $GLOBALS['_HTML_QuickForm_registered_rules'] when the tests are ran all together
2600    * (NB unclear if this is still required)
2601    */
2602   function _sethtmlGlobals() {
2603     $GLOBALS['_HTML_QuickForm_registered_rules'] = array(
2604       'required' => array(
2605         'html_quickform_rule_required',
2606         'HTML/QuickForm/Rule/Required.php'
2607       ),
2608       'maxlength' => array(
2609         'html_quickform_rule_range',
2610         'HTML/QuickForm/Rule/Range.php'
2611       ),
2612       'minlength' => array(
2613         'html_quickform_rule_range',
2614         'HTML/QuickForm/Rule/Range.php'
2615       ),
2616       'rangelength' => array(
2617         'html_quickform_rule_range',
2618         'HTML/QuickForm/Rule/Range.php'
2619       ),
2620       'email' => array(
2621         'html_quickform_rule_email',
2622         'HTML/QuickForm/Rule/Email.php'
2623       ),
2624       'regex' => array(
2625         'html_quickform_rule_regex',
2626         'HTML/QuickForm/Rule/Regex.php'
2627       ),
2628       'lettersonly' => array(
2629         'html_quickform_rule_regex',
2630         'HTML/QuickForm/Rule/Regex.php'
2631       ),
2632       'alphanumeric' => array(
2633         'html_quickform_rule_regex',
2634         'HTML/QuickForm/Rule/Regex.php'
2635       ),
2636       'numeric' => array(
2637         'html_quickform_rule_regex',
2638         'HTML/QuickForm/Rule/Regex.php'
2639       ),
2640       'nopunctuation' => array(
2641         'html_quickform_rule_regex',
2642         'HTML/QuickForm/Rule/Regex.php'
2643       ),
2644       'nonzero' => array(
2645         'html_quickform_rule_regex',
2646         'HTML/QuickForm/Rule/Regex.php'
2647       ),
2648       'callback' => array(
2649         'html_quickform_rule_callback',
2650         'HTML/QuickForm/Rule/Callback.php'
2651       ),
2652       'compare' => array(
2653         'html_quickform_rule_compare',
2654         'HTML/QuickForm/Rule/Compare.php'
2655       )
2656     );
2657     // FIXME: …ditto for $GLOBALS['HTML_QUICKFORM_ELEMENT_TYPES']
2658     $GLOBALS['HTML_QUICKFORM_ELEMENT_TYPES'] = array(
2659       'group' => array(
2660         'HTML/QuickForm/group.php',
2661         'HTML_QuickForm_group'
2662       ),
2663       'hidden' => array(
2664         'HTML/QuickForm/hidden.php',
2665         'HTML_QuickForm_hidden'
2666       ),
2667       'reset' => array(
2668         'HTML/QuickForm/reset.php',
2669         'HTML_QuickForm_reset'
2670       ),
2671       'checkbox' => array(
2672         'HTML/QuickForm/checkbox.php',
2673         'HTML_QuickForm_checkbox'
2674       ),
2675       'file' => array(
2676         'HTML/QuickForm/file.php',
2677         'HTML_QuickForm_file'
2678       ),
2679       'image' => array(
2680         'HTML/QuickForm/image.php',
2681         'HTML_QuickForm_image'
2682       ),
2683       'password' => array(
2684         'HTML/QuickForm/password.php',
2685         'HTML_QuickForm_password'
2686       ),
2687       'radio' => array(
2688         'HTML/QuickForm/radio.php',
2689         'HTML_QuickForm_radio'
2690       ),
2691       'button' => array(
2692         'HTML/QuickForm/button.php',
2693         'HTML_QuickForm_button'
2694       ),
2695       'submit' => array(
2696         'HTML/QuickForm/submit.php',
2697         'HTML_QuickForm_submit'
2698       ),
2699       'select' => array(
2700         'HTML/QuickForm/select.php',
2701         'HTML_QuickForm_select'
2702       ),
2703       'hiddenselect' => array(
2704         'HTML/QuickForm/hiddenselect.php',
2705         'HTML_QuickForm_hiddenselect'
2706       ),
2707       'text' => array(
2708         'HTML/QuickForm/text.php',
2709         'HTML_QuickForm_text'
2710       ),
2711       'textarea' => array(
2712         'HTML/QuickForm/textarea.php',
2713         'HTML_QuickForm_textarea'
2714       ),
2715       'fckeditor' => array(
2716         'HTML/QuickForm/fckeditor.php',
2717         'HTML_QuickForm_FCKEditor'
2718       ),
2719       'tinymce' => array(
2720         'HTML/QuickForm/tinymce.php',
2721         'HTML_QuickForm_TinyMCE'
2722       ),
2723       'dojoeditor' => array(
2724         'HTML/QuickForm/dojoeditor.php',
2725         'HTML_QuickForm_dojoeditor'
2726       ),
2727       'link' => array(
2728         'HTML/QuickForm/link.php',
2729         'HTML_QuickForm_link'
2730       ),
2731       'advcheckbox' => array(
2732         'HTML/QuickForm/advcheckbox.php',
2733         'HTML_QuickForm_advcheckbox'
2734       ),
2735       'date' => array(
2736         'HTML/QuickForm/date.php',
2737         'HTML_QuickForm_date'
2738       ),
2739       'static' => array(
2740         'HTML/QuickForm/static.php',
2741         'HTML_QuickForm_static'
2742       ),
2743       'header' => array(
2744         'HTML/QuickForm/header.php',
2745         'HTML_QuickForm_header'
2746       ),
2747       'html' => array(
2748         'HTML/QuickForm/html.php',
2749         'HTML_QuickForm_html'
2750       ),
2751       'hierselect' => array(
2752         'HTML/QuickForm/hierselect.php',
2753         'HTML_QuickForm_hierselect'
2754       ),
2755       'autocomplete' => array(
2756         'HTML/QuickForm/autocomplete.php',
2757         'HTML_QuickForm_autocomplete'
2758       ),
2759       'xbutton' => array(
2760         'HTML/QuickForm/xbutton.php',
2761         'HTML_QuickForm_xbutton'
2762       ),
2763       'advmultiselect' => array(
2764         'HTML/QuickForm/advmultiselect.php',
2765         'HTML_QuickForm_advmultiselect'
2766       )
2767     );
2768   }
2769
2770   /**
2771    * Set up an acl allowing contact to see 2 specified groups
2772    *  - $this->_permissionedGroup & $this->_permissionedDisbaledGroup
2773    *
2774    *  You need to have precreated these groups & created the user e.g
2775    *  $this->createLoggedInUser();
2776    *   $this->_permissionedDisabledGroup = $this->groupCreate(array('title' => 'pick-me-disabled', 'is_active' => 0, 'name' => 'pick-me-disabled'));
2777    *   $this->_permissionedGroup = $this->groupCreate(array('title' => 'pick-me-active', 'is_active' => 1, 'name' => 'pick-me-active'));
2778    *
2779    */
2780   function setupACL() {
2781     global $_REQUEST;
2782     $_REQUEST = $this->_params;
2783     CRM_Core_Config::singleton()->userPermissionClass->permissions = array('access CiviCRM');
2784     $optionGroupID = $this->callAPISuccessGetValue('option_group', array('return' => 'id', 'name' => 'acl_role'));
2785     $optionValue = $this->callAPISuccess('option_value', 'create', array('option_group_id' => $optionGroupID,
2786       'label' => 'pick me',
2787       'value' => 55,
2788     ));
2789
2790
2791     CRM_Core_DAO::executeQuery("
2792       TRUNCATE civicrm_acl_cache
2793     ");
2794
2795     CRM_Core_DAO::executeQuery("
2796       TRUNCATE civicrm_acl_contact_cache
2797     ");
2798
2799
2800     CRM_Core_DAO::executeQuery("
2801     INSERT INTO civicrm_acl_entity_role (
2802     `acl_role_id`, `entity_table`, `entity_id`
2803     ) VALUES (55, 'civicrm_group', {$this->_permissionedGroup});
2804     ");
2805
2806     CRM_Core_DAO::executeQuery("
2807     INSERT INTO civicrm_acl (
2808     `name`, `entity_table`, `entity_id`, `operation`, `object_table`, `object_id`, `is_active`
2809     )
2810     VALUES (
2811     'view picked', 'civicrm_group', $this->_permissionedGroup , 'Edit', 'civicrm_saved_search', {$this->_permissionedGroup}, 1
2812     );
2813     ");
2814
2815     CRM_Core_DAO::executeQuery("
2816     INSERT INTO civicrm_acl (
2817     `name`, `entity_table`, `entity_id`, `operation`, `object_table`, `object_id`, `is_active`
2818     )
2819     VALUES (
2820     'view picked', 'civicrm_group',  $this->_permissionedGroup, 'Edit', 'civicrm_saved_search', {$this->_permissionedDisabledGroup}, 1
2821     );
2822     ");
2823     $this->_loggedInUser = CRM_Core_Session::singleton()->get('userID');
2824     $this->callAPISuccess('group_contact', 'create', array(
2825       'group_id' => $this->_permissionedGroup,
2826       'contact_id' => $this->_loggedInUser,
2827     ));
2828     //flush cache
2829     CRM_ACL_BAO_Cache::resetCache();
2830     CRM_Contact_BAO_Group::getPermissionClause(TRUE);
2831     CRM_ACL_API::groupPermission('whatever', 9999, NULL, 'civicrm_saved_search', NULL, NULL, TRUE);
2832   }
2833
2834 /**
2835  * Create an instance of the paypal processor
2836  * @todo this isn't a great place to put it - but really it belongs on a class that extends
2837  * this parent class & we don't have a structure for that yet
2838  * There is another function to this effect on the PaypalPro test but it appears to be silently failing
2839  * & the best protection agains that is the functions this class affords
2840  */
2841  function paymentProcessorCreate($params = array()) {
2842    $params = array_merge(array(
2843      'name' => 'demo',
2844      'domain_id' => CRM_Core_Config::domainID(),
2845      'payment_processor_type_id' => 'PayPal',
2846      'is_active' => 1,
2847      'is_default' => 0,
2848      'is_test' => 1,
2849      'user_name' => 'sunil._1183377782_biz_api1.webaccess.co.in',
2850      'password' => '1183377788',
2851      'signature' => 'APixCoQ-Zsaj-u3IH7mD5Do-7HUqA9loGnLSzsZga9Zr-aNmaJa3WGPH',
2852      'url_site' => 'https://www.sandbox.paypal.com/',
2853      'url_api' => 'https://api-3t.sandbox.paypal.com/',
2854      'url_button' => 'https://www.paypal.com/en_US/i/btn/btn_xpressCheckout.gif',
2855      'class_name' => 'Payment_PayPalImpl',
2856      'billing_mode' => 3,
2857      'financial_type_id' => 1,
2858      ),
2859    $params);
2860    if(!is_numeric($params['payment_processor_type_id'])) {
2861      // really the api should handle this through getoptions but it's not exactly api call so lets just sort it
2862      //here
2863      $params['payment_processor_type_id'] = $this->callAPISuccess('payment_processor_type', 'getvalue', array(
2864        'name' => $params['payment_processor_type_id'],
2865        'return' => 'id',
2866        ), 'integer');
2867    }
2868    $result = $this->callAPISuccess('payment_processor', 'create', $params);
2869    return $result['id'];
2870  }
2871
2872
2873   /**
2874    * @param $message
2875    *
2876    * @throws Exception
2877    */function CiviUnitTestCase_fatalErrorHandler($message) {
2878   throw new Exception("{$message['message']}: {$message['code']}");
2879 }
2880 }