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     $this->_sethtmlGlobals();
 381   }
 382
 383   /**
 384    * Read everything from the datasets directory and insert into the db
 385    */
 386   public function loadAllFixtures() {
 387     $fixturesDir = __DIR__ . '/../../fixtures';
 388
 389     $this->getConnection()->getConnection()->query("SET FOREIGN_KEY_CHECKS = 0;");
 390
 391     $xmlFiles = glob($fixturesDir . '/*.xml');
 392     foreach ($xmlFiles as $xmlFixture) {
 393       $op = new PHPUnit_Extensions_Database_Operation_Insert();
 394       $dataset = new PHPUnit_Extensions_Database_DataSet_XMLDataSet($xmlFixture);
 395       $this->_tablesToTruncate = array_merge($this->_tablesToTruncate, $dataset->getTableNames());
 396       $op->execute($this->_dbconn, $dataset);
 397     }
 398
 399     $yamlFiles = glob($fixturesDir . '/*.yaml');
 400     foreach ($yamlFiles as $yamlFixture) {
 401       $op = new PHPUnit_Extensions_Database_Operation_Insert();
 402       $dataset = new PHPUnit_Extensions_Database_DataSet_YamlDataSet($yamlFixture);
 403       $this->_tablesToTruncate = array_merge($this->_tablesToTruncate, $dataset->getTableNames());
 404       $op->execute($this->_dbconn, $dataset);
 405     }
 406
 407     $this->getConnection()->getConnection()->query("SET FOREIGN_KEY_CHECKS = 1;");
 408   }
 409
 410   /**
 411    * emulate a logged in user since certain functions use that
 412    * value to store a record in the DB (like activity)
 413    * CRM-8180
 414    */
 415   public function createLoggedInUser() {
 416     $params = array(
 417       'first_name' => 'Logged In',
 418       'last_name' => 'User ' . rand(),
 419       'contact_type' => 'Individual',
 420     );
 421     $contactID = $this->individualCreate($params);
 422
 423     $session = CRM_Core_Session::singleton();
 424     $session->set('userID', $contactID);
 425   }
 426
 427   public function cleanDB() {
 428     self::$populateOnce = NULL;
 429     $this->DBResetRequired = TRUE;
 430
 431     $this->_dbconn = $this->getConnection();
 432     static::_populateDB();
 433     $this->tempDirs = array();
 434   }
 435
 436   /**
 437    *  Common teardown functions for all unit tests
 438    */
 439   protected function tearDown() {
 440     error_reporting(E_ALL & ~E_NOTICE);
 441     $tablesToTruncate = array('civicrm_contact');
 442     $this->quickCleanup($tablesToTruncate);
 443     $this->cleanTempDirs();
 444     $this->unsetExtensionSystem();
 445   }
 446
 447   /**
 448    *  FIXME: Maybe a better way to do it
 449    */
 450   function foreignKeyChecksOff() {
 451     self::$utils = new Utils($GLOBALS['mysql_host'],
 452       $GLOBALS['mysql_port'],
 453       $GLOBALS['mysql_user'],
 454       $GLOBALS['mysql_pass']
 455     );
 456     $dbName = self::getDBName();
 457     $query = "USE {$dbName};" . "SET foreign_key_checks = 1";
 458     if (self::$utils->do_query($query) === FALSE) {
 459       // fail happens
 460       echo 'Cannot set foreign_key_checks = 0';
 461       exit(1);
 462     }
 463     return TRUE;
 464   }
 465
 466   function foreignKeyChecksOn() {
 467     // FIXME: might not be needed if previous fixme implemented
 468   }
 469
 470   /**
 471    * Generic function to compare expected values after an api call to retrieved
 472    * DB values.
 473    *
 474    * @daoName  string   DAO Name of object we're evaluating.
 475    * @id       int      Id of object
 476    * @match    array    Associative array of field name => expected value. Empty if asserting
 477    *                      that a DELETE occurred
 478    * @delete   boolean  True if we're checking that a DELETE action occurred.
 479    */
 480   function assertDBState($daoName, $id, $match, $delete = FALSE) {
 481     if (empty($id)) {
 482       // adding this here since developers forget to check for an id
 483       // and hence we get the first value in the db
 484       $this->fail('ID not populated. Please fix your assertDBState usage!!!');
 485     }
 486
 487     $object = new $daoName();
 488     $object->id = $id;
 489     $verifiedCount = 0;
 490
 491     // If we're asserting successful record deletion, make sure object is NOT found.
 492     if ($delete) {
 493       if ($object->find(TRUE)) {
 494         $this->fail("Object not deleted by delete operation: $daoName, $id");
 495       }
 496       return;
 497     }
 498
 499     // Otherwise check matches of DAO field values against expected values in $match.
 500     if ($object->find(TRUE)) {
 501       $fields = & $object->fields();
 502       foreach ($fields as $name => $value) {
 503         $dbName = $value['name'];
 504         if (isset($match[$name])) {
 505           $verifiedCount++;
 506           $this->assertEquals($object->$dbName, $match[$name]);
 507         }
 508         elseif (isset($match[$dbName])) {
 509           $verifiedCount++;
 510           $this->assertEquals($object->$dbName, $match[$dbName]);
 511         }
 512       }
 513     }
 514     else {
 515       $this->fail("Could not retrieve object: $daoName, $id");
 516     }
 517     $object->free();
 518     $matchSize = count($match);
 519     if ($verifiedCount != $matchSize) {
 520       $this->fail("Did not verify all fields in match array: $daoName, $id. Verified count = $verifiedCount. Match array size = $matchSize");
 521     }
 522   }
 523
 524   // Request a record from the DB by seachColumn+searchValue. Success if a record is found.
 525   /**
 526    * @param $daoName
 527    * @param $searchValue
 528    * @param $returnColumn
 529    * @param $searchColumn
 530    * @param $message
 531    *
 532    * @return null|string
 533    * @throws PHPUnit_Framework_AssertionFailedError
 534    */
 535   function assertDBNotNull($daoName, $searchValue, $returnColumn, $searchColumn, $message) {
 536     if (empty($searchValue)) {
 537       $this->fail("empty value passed to assertDBNotNull");
 538     }
 539     $value = CRM_Core_DAO::getFieldValue($daoName, $searchValue, $returnColumn, $searchColumn, TRUE);
 540     $this->assertNotNull($value, $message);
 541
 542     return $value;
 543   }
 544
 545   // Request a record from the DB by seachColumn+searchValue. Success if returnColumn value is NULL.
 546   /**
 547    * @param $daoName
 548    * @param $searchValue
 549    * @param $returnColumn
 550    * @param $searchColumn
 551    * @param $message
 552    */
 553   function assertDBNull($daoName, $searchValue, $returnColumn, $searchColumn, $message) {
 554     $value = CRM_Core_DAO::getFieldValue($daoName, $searchValue, $returnColumn, $searchColumn, TRUE);
 555     $this->assertNull($value, $message);
 556   }
 557
 558   // Request a record from the DB by id. Success if row not found.
 559   /**
 560    * @param $daoName
 561    * @param $id
 562    * @param null $message
 563    */
 564   function assertDBRowNotExist($daoName, $id, $message = NULL) {
 565     $message = $message ? $message : "$daoName (#$id) should not exist";
 566     $value = CRM_Core_DAO::getFieldValue($daoName, $id, 'id', 'id', TRUE);
 567     $this->assertNull($value, $message);
 568   }
 569
 570   // Request a record from the DB by id. Success if row not found.
 571   /**
 572    * @param $daoName
 573    * @param $id
 574    * @param null $message
 575    */
 576   function assertDBRowExist($daoName, $id, $message = NULL) {
 577     $message = $message ? $message : "$daoName (#$id) should exist";
 578     $value = CRM_Core_DAO::getFieldValue($daoName, $id, 'id', 'id', TRUE);
 579     $this->assertEquals($id, $value, $message);
 580   }
 581
 582   // Compare a single column value in a retrieved DB record to an expected value
 583   /**
 584    * @param $daoName
 585    * @param $searchValue
 586    * @param $returnColumn
 587    * @param $searchColumn
 588    * @param $expectedValue
 589    * @param $message
 590    */
 591   function assertDBCompareValue($daoName, $searchValue, $returnColumn, $searchColumn,
 592                                 $expectedValue, $message
 593   ) {
 594     $value = CRM_Core_DAO::getFieldValue($daoName, $searchValue, $returnColumn, $searchColumn, TRUE);
 595     $this->assertEquals($value, $expectedValue, $message);
 596   }
 597
 598   // Compare all values in a single retrieved DB record to an array of expected values
 599   /**
 600    * @param $daoName
 601    * @param $searchParams
 602    * @param $expectedValues
 603    */
 604   function assertDBCompareValues($daoName, $searchParams, $expectedValues) {
 605     //get the values from db
 606     $dbValues = array();
 607     CRM_Core_DAO::commonRetrieve($daoName, $searchParams, $dbValues);
 608
 609     // compare db values with expected values
 610     self::assertAttributesEquals($expectedValues, $dbValues);
 611   }
 612
 613   /**
 614    * Assert that a SQL query returns a given value
 615    *
 616    * The first argument is an expected value. The remaining arguments are passed
 617    * to CRM_Core_DAO::singleValueQuery
 618    *
 619    * Example: $this->assertSql(2, 'select count(*) from foo where foo.bar like "%1"',
 620    * array(1 => array("Whiz", "String")));
 621    */
 622   function assertDBQuery($expected, $query, $params = array()) {
 623     $actual = CRM_Core_DAO::singleValueQuery($query, $params);
 624     $this->assertEquals($expected, $actual,
 625       sprintf('expected=[%s] actual=[%s] query=[%s]',
 626         $expected, $actual, CRM_Core_DAO::composeQuery($query, $params, FALSE)
 627       )
 628     );
 629   }
 630
 631   /**
 632    * Assert that two array-trees are exactly equal, notwithstanding
 633    * the sorting of keys
 634    *
 635    * @param array $expected
 636    * @param array $actual
 637    */
 638   function assertTreeEquals($expected, $actual) {
 639     $e = array();
 640     $a = array();
 641     CRM_Utils_Array::flatten($expected, $e, '', ':::');
 642     CRM_Utils_Array::flatten($actual, $a, '', ':::');
 643     ksort($e);
 644     ksort($a);
 645
 646     $this->assertEquals($e, $a);
 647   }
 648
 649   /**
 650    * Assert that two numbers are approximately equal
 651    *
 652    * @param int|float $expected
 653    * @param int|float $actual
 654    * @param int|float $tolerance
 655    * @param string $message
 656    */
 657   function assertApproxEquals($expected, $actual, $tolerance, $message = NULL) {
 658     if ($message === NULL) {
 659       $message = sprintf("approx-equals: expected=[%.3f] actual=[%.3f] tolerance=[%.3f]", $expected, $actual, $tolerance);
 660     }
 661     $this->assertTrue(abs($actual - $expected) < $tolerance, $message);
 662   }
 663
 664   /**
 665    * @param $expectedValues
 666    * @param $actualValues
 667    * @param null $message
 668    *
 669    * @throws PHPUnit_Framework_AssertionFailedError
 670    */
 671   function assertAttributesEquals($expectedValues, $actualValues, $message = NULL) {
 672     foreach ($expectedValues as $paramName => $paramValue) {
 673       if (isset($actualValues[$paramName])) {
 674         $this->assertEquals($paramValue, $actualValues[$paramName], "Value Mismatch On $paramName - value 1 is " . print_r($paramValue, TRUE) . "  value 2 is " . print_r($actualValues[$paramName], TRUE) );
 675       }
 676       else {
 677         $this->fail("Attribute '$paramName' not present in actual array.");
 678       }
 679     }
 680   }
 681
 682   /**
 683    * @param $key
 684    * @param $list
 685    */
 686   function assertArrayKeyExists($key, &$list) {
 687     $result = isset($list[$key]) ? TRUE : FALSE;
 688     $this->assertTrue($result, ts("%1 element exists?",
 689       array(1 => $key)
 690     ));
 691   }
 692
 693   /**
 694    * @param $key
 695    * @param $list
 696    */
 697   function assertArrayValueNotNull($key, &$list) {
 698     $this->assertArrayKeyExists($key, $list);
 699
 700     $value = isset($list[$key]) ? $list[$key] : NULL;
 701     $this->assertTrue($value,
 702       ts("%1 element not null?",
 703         array(1 => $key)
 704       )
 705     );
 706   }
 707
 708   /**
 709    * check that api returned 'is_error' => 0
 710    * else provide full message
 711    * @param array $apiResult api result
 712    * @param string $prefix extra test to add to message
 713    */
 714   function assertAPISuccess($apiResult, $prefix = '') {
 715     if (!empty($prefix)) {
 716       $prefix .= ': ';
 717     }
 718     $errorMessage = empty($apiResult['error_message']) ? '' : " " . $apiResult['error_message'];
 719
 720     if(!empty($apiResult['debug_information'])) {
 721       $errorMessage .= "\n " . print_r($apiResult['debug_information'], TRUE);
 722     }
 723     if(!empty($apiResult['trace'])){
 724       $errorMessage .= "\n" . print_r($apiResult['trace'], TRUE);
 725     }
 726     $this->assertEquals(0, $apiResult['is_error'], $prefix . $errorMessage);
 727   }
 728
 729   /**
 730    * check that api returned 'is_error' => 1
 731    * else provide full message
 732    *
 733    * @param array $apiResult api result
 734    * @param string $prefix extra test to add to message
 735    * @param null $expectedError
 736    */
 737   function assertAPIFailure($apiResult, $prefix = '', $expectedError = NULL) {
 738     if (!empty($prefix)) {
 739       $prefix .= ': ';
 740     }
 741     if($expectedError && !empty($apiResult['is_error'])){
 742       $this->assertEquals($expectedError, $apiResult['error_message'], 'api error message not as expected' . $prefix );
 743     }
 744     $this->assertEquals(1, $apiResult['is_error'], "api call should have failed but it succeeded " . $prefix . (print_r($apiResult, TRUE)));
 745     $this->assertNotEmpty($apiResult['error_message']);
 746   }
 747
 748   /**
 749    * @param $expected
 750    * @param $actual
 751    * @param string $message
 752    */
 753   function assertType($expected, $actual, $message = '') {
 754     return $this->assertInternalType($expected, $actual, $message);
 755   }
 756
 757   /**
 758    * check that a deleted item has been deleted
 759    */
 760   function assertAPIDeleted($entity, $id) {
 761     $this->callAPISuccess($entity, 'getcount', array('id' => $id), 0);
 762   }
 763
 764
 765   /**
 766    * check that api returned 'is_error' => 1
 767    * else provide full message
 768    * @param $result
 769    * @param $expected
 770    * @param array $valuesToExclude
 771    * @param string $prefix extra test to add to message
 772    * @internal param array $apiResult api result
 773    */
 774   function assertAPIArrayComparison($result, $expected, $valuesToExclude = array(), $prefix = '') {
 775     $valuesToExclude = array_merge($valuesToExclude, array('debug', 'xdebug', 'sequential'));
 776     foreach ($valuesToExclude as $value) {
 777       if(isset($result[$value])) {
 778         unset($result[$value]);
 779       }
 780       if(isset($expected[$value])) {
 781         unset($expected[$value]);
 782       }
 783     }
 784     $this->assertEquals($result, $expected, "api result array comparison failed " . $prefix . print_r($result, TRUE) . ' was compared to ' . print_r($expected, TRUE));
 785   }
 786
 787   /**
 788    * A stub for the API interface. This can be overriden by subclasses to change how the API is called.
 789    *
 790    * @param $entity
 791    * @param $action
 792    * @param $params
 793    * @return array|int
 794    */
 795   function civicrm_api($entity, $action, $params) {
 796     return civicrm_api($entity, $action, $params);
 797   }
 798
 799   /**
 800    * This function exists to wrap api functions
 801    * so we can ensure they succeed & throw exceptions without litterering the test with checks
 802    *
 803    * @param string $entity
 804    * @param string $action
 805    * @param array $params
 806    * @param mixed $checkAgainst optional value to check result against, implemented for getvalue,
 807    *   getcount, getsingle. Note that for getvalue the type is checked rather than the value
 808    *   for getsingle the array is compared against an array passed in - the id is not compared (for
 809    *   better or worse )
 810    *
 811    * @return array|int
 812    */
 813   function callAPISuccess($entity, $action, $params, $checkAgainst = NULL) {
 814     $params = array_merge(array(
 815         'version' => $this->_apiversion,
 816         'debug' => 1,
 817       ),
 818       $params
 819     );
 820     switch (strtolower($action)) {
 821       case 'getvalue' :
 822         return $this->callAPISuccessGetValue($entity, $params, $checkAgainst);
 823       case 'getsingle' :
 824         return $this->callAPISuccessGetSingle($entity, $params, $checkAgainst);
 825       case 'getcount' :
 826           return $this->callAPISuccessGetCount($entity, $params, $checkAgainst);
 827     }
 828     $result = $this->civicrm_api($entity, $action, $params);
 829     $this->assertAPISuccess($result, "Failure in api call for $entity $action");
 830     return $result;
 831   }
 832
 833   /**
 834    * This function exists to wrap api getValue function & check the result
 835    * so we can ensure they succeed & throw exceptions without litterering the test with checks
 836    * There is a type check in this
 837    *
 838    * @param string $entity
 839    * @param array $params
 840    * @param string $type - per http://php.net/manual/en/function.gettype.php possible types
 841    * - boolean
 842    * - integer
 843    * - double
 844    * - string
 845    * - array
 846    * - object
 847    *
 848    * @return array|int
 849    */
 850   function callAPISuccessGetValue($entity, $params, $type = NULL) {
 851     $params += array(
 852       'version' => $this->_apiversion,
 853       'debug' => 1,
 854     );
 855     $result = $this->civicrm_api($entity, 'getvalue', $params);
 856     if($type){
 857       if($type == 'integer'){
 858         // api seems to return integers as strings
 859         $this->assertTrue(is_numeric($result), "expected a numeric value but got " . print_r($result, 1));
 860       }
 861       else{
 862         $this->assertType($type, $result, "returned result should have been of type $type but was " );
 863       }
 864     }
 865     return $result;
 866   }
 867
 868   /**
 869    * This function exists to wrap api getsingle function & check the result
 870    * so we can ensure they succeed & throw exceptions without litterering the test with checks
 871    *
 872    * @param string $entity
 873    * @param array $params
 874    * @param array $checkAgainst - array to compare result against
 875    * - boolean
 876    * - integer
 877    * - double
 878    * - string
 879    * - array
 880    * - object
 881    *
 882    * @throws Exception
 883    * @return array|int
 884    */
 885   function callAPISuccessGetSingle($entity, $params, $checkAgainst = NULL) {
 886     $params += array(
 887       'version' => $this->_apiversion,
 888       'debug' => 1,
 889     );
 890     $result = $this->civicrm_api($entity, 'getsingle', $params);
 891     if(!is_array($result) || !empty($result['is_error']) || isset($result['values'])) {
 892       throw new Exception('Invalid getsingle result' . print_r($result, TRUE));
 893     }
 894     if($checkAgainst){
 895       // @todo - have gone with the fn that unsets id? should we check id?
 896       $this->checkArrayEquals($result, $checkAgainst);
 897     }
 898     return $result;
 899   }
 900
 901   /**
 902    * This function exists to wrap api getValue function & check the result
 903    * so we can ensure they succeed & throw exceptions without litterering the test with checks
 904    * There is a type check in this
 905    * @param string $entity
 906    * @param array $params
 907    * @param null $count
 908    * @throws Exception
 909    * @return array|int
 910    * @internal param string $type - per http://php.net/manual/en/function.gettype.php possible types
 911    * - boolean
 912    * - integer
 913    * - double
 914    * - string
 915    * - array
 916    * - object
 917    */
 918   function callAPISuccessGetCount($entity, $params, $count = NULL) {
 919     $params += array(
 920       'version' => $this->_apiversion,
 921       'debug' => 1,
 922     );
 923     $result = $this->civicrm_api($entity, 'getcount', $params);
 924     if(!is_integer($result) || !empty($result['is_error']) || isset($result['values'])) {
 925       throw new Exception('Invalid getcount result : ' . print_r($result, TRUE) . " type :" . gettype($result));
 926     }
 927     if(is_int($count)){
 928       $this->assertEquals($count, $result, "incorect count returned from $entity getcount");
 929     }
 930     return $result;
 931   }
 932
 933   /**
 934    * This function exists to wrap api functions
 935    * so we can ensure they succeed, generate and example & throw exceptions without litterering the test with checks
 936    *
 937    * @param string $entity
 938    * @param string $action
 939    * @param array $params
 940    * @param string $function - pass this in to create a generated example
 941    * @param string $file - pass this in to create a generated example
 942    * @param string $description
 943    * @param string|null $subfile
 944    * @param string|null $actionName
 945    * @return array|int
 946    */
 947   function callAPIAndDocument($entity, $action, $params, $function, $file, $description = "", $subfile = NULL, $actionName = NULL){
 948     $params['version'] = $this->_apiversion;
 949     $result = $this->callAPISuccess($entity, $action, $params);
 950     $this->documentMe($params, $result, $function, $file, $description, $subfile, $actionName);
 951     return $result;
 952   }
 953
 954   /**
 955    * This function exists to wrap api functions
 956    * so we can ensure they fail where expected & throw exceptions without litterering the test with checks
 957    * @param string $entity
 958    * @param string $action
 959    * @param array $params
 960    * @param string $expectedErrorMessage error
 961    * @param null $extraOutput
 962    * @return array|int
 963    */
 964   function callAPIFailure($entity, $action, $params, $expectedErrorMessage = NULL, $extraOutput = NULL) {
 965     if (is_array($params)) {
 966       $params += array(
 967         'version' => $this->_apiversion,
 968       );
 969     }
 970     $result = $this->civicrm_api($entity, $action, $params);
 971     $this->assertAPIFailure($result, "We expected a failure for $entity $action but got a success");
 972     return $result;
 973   }
 974
 975   /**
 976    * Create required data based on $this->entity & $this->params
 977    * This is just a way to set up the test data for delete & get functions
 978    * so the distinction between set
 979    * up & tested functions is clearer
 980    *
 981    *  @return array api Result
 982    */
 983   public function createTestEntity(){
 984     return $entity = $this->callAPISuccess($this->entity, 'create', $this->params);
 985   }
 986
 987   /**
 988    * Generic function to create Organisation, to be used in test cases
 989    *
 990    * @param array   parameters for civicrm_contact_add api function call
 991    *
 992    * @return int    id of Organisation created
 993    */
 994   function organizationCreate($params = array()) {
 995     if (!$params) {
 996       $params = array();
 997     }
 998     $orgParams = array(
 999       'organization_name' => 'Unit Test Organization',
1000       'contact_type' => 'Organization',
1001     );
1002     return $this->_contactCreate(array_merge($orgParams, $params));
1003   }
1004
1005   /**
1006    * Generic function to create Individual, to be used in test cases
1007    *
1008    * @param array   parameters for civicrm_contact_add api function call
1009    *
1010    * @return int    id of Individual created
1011    */
1012   function individualCreate($params = array()) {
1013     $params = array_merge(array(
1014         'first_name' => 'Anthony',
1015         'middle_name' => 'J.',
1016         'last_name' => 'Anderson',
1017         'prefix_id' => 3,
1018         'suffix_id' => 3,
1019         'email' => 'anthony_anderson@civicrm.org',
1020         'contact_type' => 'Individual',
1021       ), $params);
1022
1023     return $this->_contactCreate($params);
1024   }
1025
1026   /**
1027    * Generic function to create Household, to be used in test cases
1028    *
1029    * @param array   parameters for civicrm_contact_add api function call
1030    *
1031    * @return int    id of Household created
1032    */
1033   function householdCreate($params =  array()) {
1034     $params = array_merge(array(
1035         'household_name' => 'Unit Test household',
1036         'contact_type' => 'Household',
1037       ), $params);
1038     return $this->_contactCreate($params);
1039   }
1040
1041   /**
1042    * Private helper function for calling civicrm_contact_add
1043    *
1044    * @param $params
1045    *
1046    * @throws Exception
1047    * @internal param \parameters $array for civicrm_contact_add api function call
1048    *
1049    * @return int    id of Household created
1050    */
1051   private function _contactCreate($params) {
1052     $result = $this->callAPISuccess('contact', 'create', $params);
1053     if (!empty($result['is_error']) || empty($result['id'])) {
1054       throw new Exception('Could not create test contact, with message: ' . CRM_Utils_Array::value('error_message', $result) . "\nBacktrace:" . CRM_Utils_Array::value('trace', $result));
1055     }
1056     return $result['id'];
1057   }
1058
1059   /**
1060    * @param $contactID
1061    *
1062    * @return array|int
1063    */
1064   function contactDelete($contactID) {
1065     $params = array(
1066       'id' => $contactID,
1067       'skip_undelete' => 1,
1068       'debug' => 1,
1069     );
1070     $domain = new CRM_Core_BAO_Domain;
1071     $domain->contact_id = $contactID;
1072     if ($domain->find(TRUE)) {
1073       // we are finding tests trying to delete the domain contact in cleanup
1074       //since this is mainly for cleanup lets put a safeguard here
1075       return;
1076     }
1077     $result = $this->callAPISuccess('contact', 'delete', $params);
1078     return  $result;
1079   }
1080
1081   /**
1082    * @param $contactTypeId
1083    *
1084    * @throws Exception
1085    */
1086   function contactTypeDelete($contactTypeId) {
1087     require_once 'CRM/Contact/BAO/ContactType.php';
1088     $result = CRM_Contact_BAO_ContactType::del($contactTypeId);
1089     if (!$result) {
1090       throw new Exception('Could not delete contact type');
1091     }
1092   }
1093
1094   /**
1095    * @param array $params
1096    *
1097    * @return mixed
1098    */
1099   function membershipTypeCreate($params = array()) {
1100     CRM_Member_PseudoConstant::flush('membershipType');
1101     CRM_Core_Config::clearDBCache();
1102     $memberOfOrganization = $this->organizationCreate();
1103     $params = array_merge(array(
1104       'name' => 'General',
1105       'duration_unit' => 'year',
1106       'duration_interval' => 1,
1107       'period_type' => 'rolling',
1108       'member_of_contact_id' => $memberOfOrganization,
1109       'domain_id' => 1,
1110       'financial_type_id' => 1,
1111       'is_active' => 1,
1112       'sequential' => 1,
1113       'visibility' => 'Public',
1114     ), $params);
1115
1116     $result = $this->callAPISuccess('MembershipType', 'Create', $params);
1117
1118     CRM_Member_PseudoConstant::flush('membershipType');
1119     CRM_Utils_Cache::singleton()->flush();
1120
1121     return $result['id'];
1122   }
1123
1124   /**
1125    * @param $params
1126    *
1127    * @return mixed
1128    */
1129   function contactMembershipCreate($params) {
1130     $pre = array(
1131       'join_date' => '2007-01-21',
1132       'start_date' => '2007-01-21',
1133       'end_date' => '2007-12-21',
1134       'source' => 'Payment',
1135     );
1136
1137     foreach ($pre as $key => $val) {
1138       if (!isset($params[$key])) {
1139         $params[$key] = $val;
1140       }
1141     }
1142
1143     $result = $this->callAPISuccess('Membership', 'create', $params);
1144     return $result['id'];
1145   }
1146
1147   /**
1148    * Function to delete Membership Type
1149    *
1150    * @param $params
1151    * @internal param int $membershipTypeID
1152    */
1153   function membershipTypeDelete($params) {
1154     $this->callAPISuccess('MembershipType', 'Delete', $params);
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_log',
2349       'civicrm_membership_status',
2350       'civicrm_event',
2351       'civicrm_participant',
2352       'civicrm_participant_payment',
2353       'civicrm_pledge',
2354     );
2355     $this->quickCleanup($tablesToTruncate);
2356   }
2357   /*
2358    * Function does a 'Get' on the entity & compares the fields in the Params with those returned
2359    * Default behaviour is to also delete the entity
2360    * @param array $params params array to check agains
2361    * @param int  $id id of the entity concerned
2362    * @param string $entity name of entity concerned (e.g. membership)
2363    * @param bool $delete should the entity be deleted as part of this check
2364    * @param string $errorText text to print on error
2365    *
2366    */
2367   /**
2368    * @param $params
2369    * @param $id
2370    * @param $entity
2371    * @param int $delete
2372    * @param string $errorText
2373    *
2374    * @throws Exception
2375    */
2376   function getAndCheck($params, $id, $entity, $delete = 1, $errorText = '') {
2377
2378     $result = $this->callAPISuccessGetSingle($entity, array(
2379       'id' => $id,
2380     ));
2381
2382     if ($delete) {
2383       $this->callAPISuccess($entity, 'Delete', array(
2384         'id' => $id,
2385       ));
2386     }
2387     $dateFields = $keys = $dateTimeFields = array();
2388     $fields = $this->callAPISuccess($entity, 'getfields', array('version' => 3, 'action' => 'get'));
2389     foreach ($fields['values'] as $field => $settings) {
2390       if (array_key_exists($field, $result)) {
2391         $keys[CRM_Utils_Array::Value('name', $settings, $field)] = $field;
2392       }
2393       else {
2394         $keys[CRM_Utils_Array::Value('name', $settings, $field)] = CRM_Utils_Array::value('name', $settings, $field);
2395       }
2396       $type = CRM_Utils_Array::value('type', $settings);
2397       if ($type == CRM_Utils_Type::T_DATE) {
2398         $dateFields[] = $settings['name'];
2399         // we should identify both real names & unique names as dates
2400         if($field != $settings['name']) {
2401           $dateFields[] = $field;
2402         }
2403       }
2404       if($type == CRM_Utils_Type::T_DATE + CRM_Utils_Type::T_TIME) {
2405         $dateTimeFields[] = $settings['name'];
2406         // we should identify both real names & unique names as dates
2407         if($field != $settings['name']) {
2408           $dateTimeFields[] = $field;
2409         }
2410       }
2411     }
2412
2413     if (strtolower($entity) == 'contribution') {
2414       $params['receive_date'] = date('Y-m-d', strtotime($params['receive_date']));
2415       // this is not returned in id format
2416       unset($params['payment_instrument_id']);
2417       $params['contribution_source'] = $params['source'];
2418       unset($params['source']);
2419     }
2420
2421     foreach ($params as $key => $value) {
2422       if ($key == 'version' || substr($key, 0, 3) == 'api' || !array_key_exists($keys[$key], $result)) {
2423         continue;
2424       }
2425       if (in_array($key, $dateFields)) {
2426         $value = date('Y-m-d', strtotime($value));
2427         $result[$key] = date('Y-m-d', strtotime($result[$key]));
2428       }
2429       if (in_array($key, $dateTimeFields)) {
2430         $value = date('Y-m-d H:i:s', strtotime($value));
2431         $result[$keys[$key]] = date('Y-m-d H:i:s', strtotime(CRM_Utils_Array::value($keys[$key], $result, CRM_Utils_Array::value($key, $result))));
2432       }
2433       $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);
2434     }
2435   }
2436
2437   /**
2438    * Function to get formatted values in  the actual and expected result
2439    * @param array $actual actual calculated values
2440    * @param array $expected expected values
2441    *
2442    */
2443   function checkArrayEquals(&$actual, &$expected) {
2444     self::unsetId($actual);
2445     self::unsetId($expected);
2446     $this->assertEquals($actual, $expected);
2447   }
2448
2449   /**
2450    * Function to unset the key 'id' from the array
2451    * @param array $unformattedArray The array from which the 'id' has to be unset
2452    *
2453    */
2454   static function unsetId(&$unformattedArray) {
2455     $formattedArray = array();
2456     if (array_key_exists('id', $unformattedArray)) {
2457       unset($unformattedArray['id']);
2458     }
2459     if (!empty($unformattedArray['values']) && is_array($unformattedArray['values'])) {
2460       foreach ($unformattedArray['values'] as $key => $value) {
2461         if (is_Array($value)) {
2462           foreach ($value as $k => $v) {
2463             if ($k == 'id') {
2464               unset($value[$k]);
2465             }
2466           }
2467         }
2468         elseif ($key == 'id') {
2469           $unformattedArray[$key];
2470         }
2471         $formattedArray = array($value);
2472       }
2473       $unformattedArray['values'] = $formattedArray;
2474     }
2475   }
2476
2477   /**
2478    *  Helper to enable/disable custom directory support
2479    *
2480    * @param array $customDirs with members:
2481    *   'php_path' Set to TRUE to use the default, FALSE or "" to disable support, or a string path to use another path
2482    *   'template_path' Set to TRUE to use the default, FALSE or "" to disable support, or a string path to use another path
2483    */
2484   function customDirectories($customDirs) {
2485     require_once 'CRM/Core/Config.php';
2486     $config = CRM_Core_Config::singleton();
2487
2488     if (empty($customDirs['php_path']) || $customDirs['php_path'] === FALSE) {
2489       unset($config->customPHPPathDir);
2490     }
2491     elseif ($customDirs['php_path'] === TRUE) {
2492       $config->customPHPPathDir = dirname(dirname(__FILE__)) . '/custom_directories/php/';
2493     }
2494     else {
2495       $config->customPHPPathDir = $php_path;
2496     }
2497
2498     if (empty($customDirs['template_path']) || $customDirs['template_path'] === FALSE) {
2499       unset($config->customTemplateDir);
2500     }
2501     elseif ($customDirs['template_path'] === TRUE) {
2502       $config->customTemplateDir = dirname(dirname(__FILE__)) . '/custom_directories/templates/';
2503     }
2504     else {
2505       $config->customTemplateDir = $template_path;
2506     }
2507   }
2508
2509   /**
2510    * Generate a temporary folder
2511    *
2512    * @param string $prefix
2513    * @return string $string
2514    */
2515   function createTempDir($prefix = 'test-') {
2516     $tempDir = CRM_Utils_File::tempdir($prefix);
2517     $this->tempDirs[] = $tempDir;
2518     return $tempDir;
2519   }
2520
2521   function cleanTempDirs() {
2522     if (!is_array($this->tempDirs)) {
2523       // fix test errors where this is not set
2524       return;
2525     }
2526     foreach ($this->tempDirs as $tempDir) {
2527       if (is_dir($tempDir)) {
2528         CRM_Utils_File::cleanDir($tempDir, TRUE, FALSE);
2529       }
2530     }
2531   }
2532
2533   /**
2534    * Temporarily replace the singleton extension with a different one
2535    */
2536   function setExtensionSystem(CRM_Extension_System $system) {
2537     if ($this->origExtensionSystem == NULL) {
2538       $this->origExtensionSystem = CRM_Extension_System::singleton();
2539     }
2540     CRM_Extension_System::setSingleton($this->origExtensionSystem);
2541   }
2542
2543   function unsetExtensionSystem() {
2544     if ($this->origExtensionSystem !== NULL) {
2545       CRM_Extension_System::setSingleton($this->origExtensionSystem);
2546       $this->origExtensionSystem = NULL;
2547     }
2548   }
2549
2550   /**
2551    * Temporarily alter the settings-metadata to add a mock setting.
2552    *
2553    * WARNING: The setting metadata will disappear on the next cache-clear.
2554    *
2555    * @param $extras
2556    * @return void
2557    */
2558   function setMockSettingsMetaData($extras) {
2559     CRM_Core_BAO_Setting::$_cache = array();
2560     $this->callAPISuccess('system','flush', array());
2561     CRM_Core_BAO_Setting::$_cache = array();
2562
2563     CRM_Utils_Hook::singleton()->setHook('civicrm_alterSettingsMetaData', function (&$metadata, $domainId, $profile) use ($extras) {
2564       $metadata = array_merge($metadata, $extras);
2565     });
2566
2567     $fields = $this->callAPISuccess('setting', 'getfields', array());
2568     foreach ($extras as $key => $spec) {
2569       $this->assertNotEmpty($spec['title']);
2570       $this->assertEquals($spec['title'], $fields['values'][$key]['title']);
2571     }
2572   }
2573
2574   /**
2575    * @param $name
2576    */
2577   function financialAccountDelete($name) {
2578     $financialAccount = new CRM_Financial_DAO_FinancialAccount();
2579     $financialAccount->name = $name;
2580     if($financialAccount->find(TRUE)) {
2581       $entityFinancialType = new CRM_Financial_DAO_EntityFinancialAccount();
2582       $entityFinancialType->financial_account_id = $financialAccount->id;
2583       $entityFinancialType->delete();
2584       $financialAccount->delete();
2585     }
2586   }
2587
2588   /**
2589    * Use $ids as an instruction to do test cleanup
2590    */
2591   function deleteFromIDSArray() {
2592     foreach ($this->ids as $entity => $ids) {
2593       foreach ($ids as $id) {
2594         $this->callAPISuccess($entity, 'delete', array('id' => $id));
2595       }
2596     }
2597   }
2598
2599   /**
2600    * FIXME: something NULLs $GLOBALS['_HTML_QuickForm_registered_rules'] when the tests are ran all together
2601    * (NB unclear if this is still required)
2602    */
2603   function _sethtmlGlobals() {
2604     $GLOBALS['_HTML_QuickForm_registered_rules'] = array(
2605       'required' => array(
2606         'html_quickform_rule_required',
2607         'HTML/QuickForm/Rule/Required.php'
2608       ),
2609       'maxlength' => array(
2610         'html_quickform_rule_range',
2611         'HTML/QuickForm/Rule/Range.php'
2612       ),
2613       'minlength' => array(
2614         'html_quickform_rule_range',
2615         'HTML/QuickForm/Rule/Range.php'
2616       ),
2617       'rangelength' => array(
2618         'html_quickform_rule_range',
2619         'HTML/QuickForm/Rule/Range.php'
2620       ),
2621       'email' => array(
2622         'html_quickform_rule_email',
2623         'HTML/QuickForm/Rule/Email.php'
2624       ),
2625       'regex' => array(
2626         'html_quickform_rule_regex',
2627         'HTML/QuickForm/Rule/Regex.php'
2628       ),
2629       'lettersonly' => array(
2630         'html_quickform_rule_regex',
2631         'HTML/QuickForm/Rule/Regex.php'
2632       ),
2633       'alphanumeric' => array(
2634         'html_quickform_rule_regex',
2635         'HTML/QuickForm/Rule/Regex.php'
2636       ),
2637       'numeric' => array(
2638         'html_quickform_rule_regex',
2639         'HTML/QuickForm/Rule/Regex.php'
2640       ),
2641       'nopunctuation' => array(
2642         'html_quickform_rule_regex',
2643         'HTML/QuickForm/Rule/Regex.php'
2644       ),
2645       'nonzero' => array(
2646         'html_quickform_rule_regex',
2647         'HTML/QuickForm/Rule/Regex.php'
2648       ),
2649       'callback' => array(
2650         'html_quickform_rule_callback',
2651         'HTML/QuickForm/Rule/Callback.php'
2652       ),
2653       'compare' => array(
2654         'html_quickform_rule_compare',
2655         'HTML/QuickForm/Rule/Compare.php'
2656       )
2657     );
2658     // FIXME: …ditto for $GLOBALS['HTML_QUICKFORM_ELEMENT_TYPES']
2659     $GLOBALS['HTML_QUICKFORM_ELEMENT_TYPES'] = array(
2660       'group' => array(
2661         'HTML/QuickForm/group.php',
2662         'HTML_QuickForm_group'
2663       ),
2664       'hidden' => array(
2665         'HTML/QuickForm/hidden.php',
2666         'HTML_QuickForm_hidden'
2667       ),
2668       'reset' => array(
2669         'HTML/QuickForm/reset.php',
2670         'HTML_QuickForm_reset'
2671       ),
2672       'checkbox' => array(
2673         'HTML/QuickForm/checkbox.php',
2674         'HTML_QuickForm_checkbox'
2675       ),
2676       'file' => array(
2677         'HTML/QuickForm/file.php',
2678         'HTML_QuickForm_file'
2679       ),
2680       'image' => array(
2681         'HTML/QuickForm/image.php',
2682         'HTML_QuickForm_image'
2683       ),
2684       'password' => array(
2685         'HTML/QuickForm/password.php',
2686         'HTML_QuickForm_password'
2687       ),
2688       'radio' => array(
2689         'HTML/QuickForm/radio.php',
2690         'HTML_QuickForm_radio'
2691       ),
2692       'button' => array(
2693         'HTML/QuickForm/button.php',
2694         'HTML_QuickForm_button'
2695       ),
2696       'submit' => array(
2697         'HTML/QuickForm/submit.php',
2698         'HTML_QuickForm_submit'
2699       ),
2700       'select' => array(
2701         'HTML/QuickForm/select.php',
2702         'HTML_QuickForm_select'
2703       ),
2704       'hiddenselect' => array(
2705         'HTML/QuickForm/hiddenselect.php',
2706         'HTML_QuickForm_hiddenselect'
2707       ),
2708       'text' => array(
2709         'HTML/QuickForm/text.php',
2710         'HTML_QuickForm_text'
2711       ),
2712       'textarea' => array(
2713         'HTML/QuickForm/textarea.php',
2714         'HTML_QuickForm_textarea'
2715       ),
2716       'fckeditor' => array(
2717         'HTML/QuickForm/fckeditor.php',
2718         'HTML_QuickForm_FCKEditor'
2719       ),
2720       'tinymce' => array(
2721         'HTML/QuickForm/tinymce.php',
2722         'HTML_QuickForm_TinyMCE'
2723       ),
2724       'dojoeditor' => array(
2725         'HTML/QuickForm/dojoeditor.php',
2726         'HTML_QuickForm_dojoeditor'
2727       ),
2728       'link' => array(
2729         'HTML/QuickForm/link.php',
2730         'HTML_QuickForm_link'
2731       ),
2732       'advcheckbox' => array(
2733         'HTML/QuickForm/advcheckbox.php',
2734         'HTML_QuickForm_advcheckbox'
2735       ),
2736       'date' => array(
2737         'HTML/QuickForm/date.php',
2738         'HTML_QuickForm_date'
2739       ),
2740       'static' => array(
2741         'HTML/QuickForm/static.php',
2742         'HTML_QuickForm_static'
2743       ),
2744       'header' => array(
2745         'HTML/QuickForm/header.php',
2746         'HTML_QuickForm_header'
2747       ),
2748       'html' => array(
2749         'HTML/QuickForm/html.php',
2750         'HTML_QuickForm_html'
2751       ),
2752       'hierselect' => array(
2753         'HTML/QuickForm/hierselect.php',
2754         'HTML_QuickForm_hierselect'
2755       ),
2756       'autocomplete' => array(
2757         'HTML/QuickForm/autocomplete.php',
2758         'HTML_QuickForm_autocomplete'
2759       ),
2760       'xbutton' => array(
2761         'HTML/QuickForm/xbutton.php',
2762         'HTML_QuickForm_xbutton'
2763       ),
2764       'advmultiselect' => array(
2765         'HTML/QuickForm/advmultiselect.php',
2766         'HTML_QuickForm_advmultiselect'
2767       )
2768     );
2769   }
2770
2771   /**
2772    * Set up an acl allowing contact to see 2 specified groups
2773    *  - $this->_permissionedGroup & $this->_permissionedDisbaledGroup
2774    *
2775    *  You need to have precreated these groups & created the user e.g
2776    *  $this->createLoggedInUser();
2777    *   $this->_permissionedDisabledGroup = $this->groupCreate(array('title' => 'pick-me-disabled', 'is_active' => 0, 'name' => 'pick-me-disabled'));
2778    *   $this->_permissionedGroup = $this->groupCreate(array('title' => 'pick-me-active', 'is_active' => 1, 'name' => 'pick-me-active'));
2779    *
2780    */
2781   function setupACL() {
2782     global $_REQUEST;
2783     $_REQUEST = $this->_params;
2784     CRM_Core_Config::singleton()->userPermissionClass->permissions = array('access CiviCRM');
2785     $optionGroupID = $this->callAPISuccessGetValue('option_group', array('return' => 'id', 'name' => 'acl_role'));
2786     $optionValue = $this->callAPISuccess('option_value', 'create', array('option_group_id' => $optionGroupID,
2787       'label' => 'pick me',
2788       'value' => 55,
2789     ));
2790
2791
2792     CRM_Core_DAO::executeQuery("
2793       TRUNCATE civicrm_acl_cache
2794     ");
2795
2796     CRM_Core_DAO::executeQuery("
2797       TRUNCATE civicrm_acl_contact_cache
2798     ");
2799
2800
2801     CRM_Core_DAO::executeQuery("
2802     INSERT INTO civicrm_acl_entity_role (
2803     `acl_role_id`, `entity_table`, `entity_id`
2804     ) VALUES (55, 'civicrm_group', {$this->_permissionedGroup});
2805     ");
2806
2807     CRM_Core_DAO::executeQuery("
2808     INSERT INTO civicrm_acl (
2809     `name`, `entity_table`, `entity_id`, `operation`, `object_table`, `object_id`, `is_active`
2810     )
2811     VALUES (
2812     'view picked', 'civicrm_group', $this->_permissionedGroup , 'Edit', 'civicrm_saved_search', {$this->_permissionedGroup}, 1
2813     );
2814     ");
2815
2816     CRM_Core_DAO::executeQuery("
2817     INSERT INTO civicrm_acl (
2818     `name`, `entity_table`, `entity_id`, `operation`, `object_table`, `object_id`, `is_active`
2819     )
2820     VALUES (
2821     'view picked', 'civicrm_group',  $this->_permissionedGroup, 'Edit', 'civicrm_saved_search', {$this->_permissionedDisabledGroup}, 1
2822     );
2823     ");
2824     $this->_loggedInUser = CRM_Core_Session::singleton()->get('userID');
2825     $this->callAPISuccess('group_contact', 'create', array(
2826       'group_id' => $this->_permissionedGroup,
2827       'contact_id' => $this->_loggedInUser,
2828     ));
2829     //flush cache
2830     CRM_ACL_BAO_Cache::resetCache();
2831     CRM_Contact_BAO_Group::getPermissionClause(TRUE);
2832     CRM_ACL_API::groupPermission('whatever', 9999, NULL, 'civicrm_saved_search', NULL, NULL, TRUE);
2833   }
2834
2835   /**
2836    * alter default price set so that the field numbers are not all 1 (hiding errors)
2837    */
2838   function offsetDefaultPriceSet() {
2839     $contributionPriceSet = $this->callAPISuccess('price_set', 'getsingle', array('name' => 'default_contribution_amount'));
2840     $firstID = $contributionPriceSet['id'];
2841     $this->callAPISuccess('price_set', 'create', array('id' => $contributionPriceSet['id'], 'is_active' => 0, 'name' => 'old'));
2842     unset($contributionPriceSet['id']);
2843     $newPriceSet = $this->callAPISuccess('price_set', 'create', $contributionPriceSet);
2844     $priceField = $this->callAPISuccess('price_field', 'getsingle', array('price_set_id' => $firstID, 'options' => array('limit' => 1)));
2845     unset($priceField['id']);
2846     $priceField['price_set_id'] = $newPriceSet['id'];
2847     $newPriceField = $this->callAPISuccess('price_field', 'create', $priceField);
2848     $priceFieldValue = $this->callAPISuccess('price_field_value', 'getsingle', array('price_set_id' => $firstID, 'sequential' => 1, 'options' => array('limit' => 1)));
2849
2850     unset($priceFieldValue['id']);
2851     //create some padding to use up ids
2852     $this->callAPISuccess('price_field_value', 'create', $priceFieldValue);
2853     $this->callAPISuccess('price_field_value', 'create', $priceFieldValue);
2854     $this->callAPISuccess('price_field_value', 'create', array_merge($priceFieldValue, array('price_field_id' => $newPriceField['id'])));
2855
2856   }
2857
2858 /**
2859  * Create an instance of the paypal processor
2860  * @todo this isn't a great place to put it - but really it belongs on a class that extends
2861  * this parent class & we don't have a structure for that yet
2862  * There is another function to this effect on the PaypalPro test but it appears to be silently failing
2863  * & the best protection agains that is the functions this class affords
2864  */
2865  function paymentProcessorCreate($params = array()) {
2866    $params = array_merge(array(
2867      'name' => 'demo',
2868      'domain_id' => CRM_Core_Config::domainID(),
2869      'payment_processor_type_id' => 'PayPal',
2870      'is_active' => 1,
2871      'is_default' => 0,
2872      'is_test' => 1,
2873      'user_name' => 'sunil._1183377782_biz_api1.webaccess.co.in',
2874      'password' => '1183377788',
2875      'signature' => 'APixCoQ-Zsaj-u3IH7mD5Do-7HUqA9loGnLSzsZga9Zr-aNmaJa3WGPH',
2876      'url_site' => 'https://www.sandbox.paypal.com/',
2877      'url_api' => 'https://api-3t.sandbox.paypal.com/',
2878      'url_button' => 'https://www.paypal.com/en_US/i/btn/btn_xpressCheckout.gif',
2879      'class_name' => 'Payment_PayPalImpl',
2880      'billing_mode' => 3,
2881      'financial_type_id' => 1,
2882      ),
2883    $params);
2884    if(!is_numeric($params['payment_processor_type_id'])) {
2885      // really the api should handle this through getoptions but it's not exactly api call so lets just sort it
2886      //here
2887      $params['payment_processor_type_id'] = $this->callAPISuccess('payment_processor_type', 'getvalue', array(
2888        'name' => $params['payment_processor_type_id'],
2889        'return' => 'id',
2890        ), 'integer');
2891    }
2892    $result = $this->callAPISuccess('payment_processor', 'create', $params);
2893    return $result['id'];
2894  }
2895
2896
2897   /**
2898    * @param $message
2899    *
2900    * @throws Exception
2901    */function CiviUnitTestCase_fatalErrorHandler($message) {
2902   throw new Exception("{$message['message']}: {$message['code']}");
2903 }
2904 }