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 use Civi\Payment\System;
  30
  31 /**
  32  *  Include class definitions
  33  */
  34 require_once 'api/api.php';
  35 define('API_LATEST_VERSION', 3);
  36
  37 /**
  38  *  Base class for CiviCRM unit tests
  39  *
  40  * This class supports two (mutually-exclusive) techniques for cleaning up test data. Subclasses
  41  * may opt for one or neither:
  42  *
  43  * 1. quickCleanup() is a helper which truncates a series of tables. Call quickCleanup()
  44  *    as part of setUp() and/or tearDown(). quickCleanup() is thorough - but it can
  45  *    be cumbersome to use (b/c you must identify the tables to cleanup) and slow to execute.
  46  * 2. useTransaction() executes the test inside a transaction. It's easier to use
  47  *    (because you don't need to identify specific tables), but it doesn't work for tests
  48  *    which manipulate schema or truncate data -- and could behave inconsistently
  49  *    for tests which specifically examine DB transactions.
  50  *
  51  *  Common functions for unit tests
  52  * @package CiviCRM
  53  */
  54 class CiviUnitTestCase extends PHPUnit_Extensions_Database_TestCase {
  55
  56   /**
  57    * Api version - easier to override than just a define
  58    */
  59   protected $_apiversion = API_LATEST_VERSION;
  60   /**
  61    *  Database has been initialized.
  62    *
  63    * @var boolean
  64    */
  65   private static $dbInit = FALSE;
  66
  67   /**
  68    *  Database connection.
  69    *
  70    * @var PHPUnit_Extensions_Database_DB_IDatabaseConnection
  71    */
  72   protected $_dbconn;
  73
  74   /**
  75    * The database name.
  76    *
  77    * @var string
  78    */
  79   static protected $_dbName;
  80
  81   /**
  82    * Track tables we have modified during a test.
  83    */
  84   protected $_tablesToTruncate = array();
  85
  86   /**
  87    * @var array of temporary directory names
  88    */
  89   protected $tempDirs;
  90
  91   /**
  92    * @var boolean populateOnce allows to skip db resets in setUp
  93    *
  94    *  WARNING! USE WITH CAUTION - IT'LL RENDER DATA DEPENDENCIES
  95    *  BETWEEN TESTS WHEN RUN IN SUITE. SUITABLE FOR LOCAL, LIMITED
  96    *  "CHECK RUNS" ONLY!
  97    *
  98    *  IF POSSIBLE, USE $this->DBResetRequired = FALSE IN YOUR TEST CASE!
  99    *
 100    *  see also: http://forum.civicrm.org/index.php/topic,18065.0.html
 101    */
 102   public static $populateOnce = FALSE;
 103
 104   /**
 105    * @var boolean DBResetRequired allows skipping DB reset
 106    *               in specific test case. If you still need
 107    *               to reset single test (method) of such case, call
 108    *               $this->cleanDB() in the first line of this
 109    *               test (method).
 110    */
 111   public $DBResetRequired = TRUE;
 112
 113   /**
 114    * @var CRM_Core_Transaction|NULL
 115    */
 116   private $tx = NULL;
 117
 118   /**
 119    * @var CRM_Utils_Hook_UnitTests hookClass
 120    * example of setting a method for a hook
 121    * $this->hookClass->setHook('civicrm_aclWhereClause', array($this, 'aclWhereHookAllResults'));
 122    */
 123   public $hookClass = NULL;
 124
 125   /**
 126    * @var array common values to be re-used multiple times within a class - usually to create the relevant entity
 127    */
 128   protected $_params = array();
 129
 130   /**
 131    * @var CRM_Extension_System
 132    */
 133   protected $origExtensionSystem;
 134
 135   /**
 136    * Array of IDs created during test setup routine.
 137    *
 138    * The cleanUpSetUpIds method can be used to clear these at the end of the test.
 139    *
 140    * @var array
 141    */
 142   public $setupIDs = array();
 143
 144   /**
 145    *  Constructor.
 146    *
 147    *  Because we are overriding the parent class constructor, we
 148    *  need to show the same arguments as exist in the constructor of
 149    *  PHPUnit_Framework_TestCase, since
 150    *  PHPUnit_Framework_TestSuite::createTest() creates a
 151    *  ReflectionClass of the Test class and checks the constructor
 152    *  of that class to decide how to set up the test.
 153    *
 154    * @param string $name
 155    * @param array $data
 156    * @param string $dataName
 157    */
 158   public function __construct($name = NULL, array$data = array(), $dataName = '') {
 159     parent::__construct($name, $data, $dataName);
 160
 161     // we need full error reporting
 162     error_reporting(E_ALL & ~E_NOTICE);
 163
 164     self::$_dbName = self::getDBName();
 165
 166     // also load the class loader
 167     require_once 'CRM/Core/ClassLoader.php';
 168     CRM_Core_ClassLoader::singleton()->register();
 169     if (function_exists('_civix_phpunit_setUp')) {
 170       // FIXME: loosen coupling
 171       _civix_phpunit_setUp();
 172     }
 173   }
 174
 175   /**
 176    * Override to run the test and assert its state.
 177    * @return mixed
 178    * @throws \Exception
 179    * @throws \PHPUnit_Framework_IncompleteTest
 180    * @throws \PHPUnit_Framework_SkippedTest
 181    */
 182   protected function runTest() {
 183     try {
 184       return parent::runTest();
 185     }
 186     catch (PEAR_Exception $e) {
 187       // PEAR_Exception has metadata in funny places, and PHPUnit won't log it nicely
 188       throw new Exception(\CRM_Core_Error::formatTextException($e), $e->getCode());
 189     }
 190   }
 191
 192   /**
 193    * @return bool
 194    */
 195   public function requireDBReset() {
 196     return $this->DBResetRequired;
 197   }
 198
 199   /**
 200    * @return string
 201    */
 202   public static function getDBName() {
 203     static $dbName = NULL;
 204     if ($dbName === NULL) {
 205       require_once "DB.php";
 206       $dsninfo = DB::parseDSN(CIVICRM_DSN);
 207       $dbName = $dsninfo['database'];
 208     }
 209     return $dbName;
 210   }
 211
 212   /**
 213    *  Create database connection for this instance.
 214    *
 215    *  Initialize the test database if it hasn't been initialized
 216    *
 217    * @return PHPUnit_Extensions_Database_DB_IDatabaseConnection connection
 218    */
 219   protected function getConnection() {
 220     $dbName = self::$_dbName;
 221     if (!self::$dbInit) {
 222       $dbName = self::getDBName();
 223
 224       //  install test database
 225       echo PHP_EOL . "Installing {$dbName} database" . PHP_EOL;
 226
 227       static::_populateDB(FALSE, $this);
 228
 229       self::$dbInit = TRUE;
 230     }
 231
 232     return $this->createDefaultDBConnection(Civi\Test::pdo(), $dbName);
 233   }
 234
 235   /**
 236    *  Required implementation of abstract method.
 237    */
 238   protected function getDataSet() {
 239   }
 240
 241   /**
 242    * @param bool $perClass
 243    * @param null $object
 244    * @return bool
 245    *   TRUE if the populate logic runs; FALSE if it is skipped
 246    */
 247   protected static function _populateDB($perClass = FALSE, &$object = NULL) {
 248     if (CIVICRM_UF !== 'UnitTests') {
 249       throw new \RuntimeException("_populateDB requires CIVICRM_UF=UnitTests");
 250     }
 251
 252     if ($perClass || $object == NULL) {
 253       $dbreset = TRUE;
 254     }
 255     else {
 256       $dbreset = $object->requireDBReset();
 257     }
 258
 259     if (self::$populateOnce || !$dbreset) {
 260       return FALSE;
 261     }
 262     self::$populateOnce = NULL;
 263
 264     Civi\Test::data()->populate();
 265
 266     return TRUE;
 267   }
 268
 269   public static function setUpBeforeClass() {
 270     static::_populateDB(TRUE);
 271
 272     // also set this global hack
 273     $GLOBALS['_PEAR_ERRORSTACK_OVERRIDE_CALLBACK'] = array();
 274   }
 275
 276   /**
 277    *  Common setup functions for all unit tests.
 278    */
 279   protected function setUp() {
 280     $session = CRM_Core_Session::singleton();
 281     $session->set('userID', NULL);
 282
 283     $this->errorScope = CRM_Core_TemporaryErrorScope::useException(); // REVERT
 284     //  Use a temporary file for STDIN
 285     $GLOBALS['stdin'] = tmpfile();
 286     if ($GLOBALS['stdin'] === FALSE) {
 287       echo "Couldn't open temporary file\n";
 288       exit(1);
 289     }
 290
 291     //  Get and save a connection to the database
 292     $this->_dbconn = $this->getConnection();
 293
 294     // reload database before each test
 295     //        $this->_populateDB();
 296
 297     // "initialize" CiviCRM to avoid problems when running single tests
 298     // FIXME: look at it closer in second stage
 299
 300     $GLOBALS['civicrm_setting']['domain']['fatalErrorHandler'] = 'CiviUnitTestCase_fatalErrorHandler';
 301     $GLOBALS['civicrm_setting']['domain']['backtrace'] = 1;
 302
 303     // disable any left-over test extensions
 304     CRM_Core_DAO::executeQuery('DELETE FROM civicrm_extension WHERE full_name LIKE "test.%"');
 305
 306     // reset all the caches
 307     CRM_Utils_System::flushCache();
 308
 309     // initialize the object once db is loaded
 310     \Civi::reset();
 311     $config = CRM_Core_Config::singleton(TRUE, TRUE); // ugh, performance
 312
 313     // when running unit tests, use mockup user framework
 314     $this->hookClass = CRM_Utils_Hook::singleton();
 315
 316     // Make sure the DB connection is setup properly
 317     $config->userSystem->setMySQLTimeZone();
 318     $env = new CRM_Utils_Check_Component_Env();
 319     CRM_Utils_Check::singleton()->assertValid($env->checkMysqlTime());
 320
 321     // clear permissions stub to not check permissions
 322     $config->userPermissionClass->permissions = NULL;
 323
 324     //flush component settings
 325     CRM_Core_Component::getEnabledComponents(TRUE);
 326
 327     error_reporting(E_ALL);
 328
 329     $this->_sethtmlGlobals();
 330   }
 331
 332   /**
 333    * Read everything from the datasets directory and insert into the db.
 334    */
 335   public function loadAllFixtures() {
 336     $fixturesDir = __DIR__ . '/../../fixtures';
 337
 338     $this->getConnection()->getConnection()->query("SET FOREIGN_KEY_CHECKS = 0;");
 339
 340     $xmlFiles = glob($fixturesDir . '/*.xml');
 341     foreach ($xmlFiles as $xmlFixture) {
 342       $op = new PHPUnit_Extensions_Database_Operation_Insert();
 343       $dataset = $this->createXMLDataSet($xmlFixture);
 344       $this->_tablesToTruncate = array_merge($this->_tablesToTruncate, $dataset->getTableNames());
 345       $op->execute($this->_dbconn, $dataset);
 346     }
 347
 348     $yamlFiles = glob($fixturesDir . '/*.yaml');
 349     foreach ($yamlFiles as $yamlFixture) {
 350       $op = new PHPUnit_Extensions_Database_Operation_Insert();
 351       $dataset = new PHPUnit_Extensions_Database_DataSet_YamlDataSet($yamlFixture);
 352       $this->_tablesToTruncate = array_merge($this->_tablesToTruncate, $dataset->getTableNames());
 353       $op->execute($this->_dbconn, $dataset);
 354     }
 355
 356     $this->getConnection()->getConnection()->query("SET FOREIGN_KEY_CHECKS = 1;");
 357   }
 358
 359   /**
 360    * Emulate a logged in user since certain functions use that.
 361    * value to store a record in the DB (like activity)
 362    * CRM-8180
 363    *
 364    * @return int
 365    *   Contact ID of the created user.
 366    */
 367   public function createLoggedInUser() {
 368     $params = array(
 369       'first_name' => 'Logged In',
 370       'last_name' => 'User ' . rand(),
 371       'contact_type' => 'Individual',
 372     );
 373     $contactID = $this->individualCreate($params);
 374     $this->callAPISuccess('UFMatch', 'create', array(
 375       'contact_id' => $contactID,
 376       'uf_name' => 'superman',
 377       'uf_id' => 6,
 378     ));
 379
 380     $session = CRM_Core_Session::singleton();
 381     $session->set('userID', $contactID);
 382     return $contactID;
 383   }
 384
 385   /**
 386    * Create default domain contacts for the two domains added during test class.
 387    * database population.
 388    */
 389   public function createDomainContacts() {
 390     $this->organizationCreate();
 391     $this->organizationCreate(array('organization_name' => 'Second Domain'));
 392   }
 393
 394   /**
 395    *  Common teardown functions for all unit tests.
 396    */
 397   protected function tearDown() {
 398     error_reporting(E_ALL & ~E_NOTICE);
 399     CRM_Utils_Hook::singleton()->reset();
 400     $this->hookClass->reset();
 401     $session = CRM_Core_Session::singleton();
 402     $session->set('userID', NULL);
 403
 404     if ($this->tx) {
 405       $this->tx->rollback()->commit();
 406       $this->tx = NULL;
 407
 408       CRM_Core_Transaction::forceRollbackIfEnabled();
 409       \Civi\Core\Transaction\Manager::singleton(TRUE);
 410     }
 411     else {
 412       CRM_Core_Transaction::forceRollbackIfEnabled();
 413       \Civi\Core\Transaction\Manager::singleton(TRUE);
 414
 415       $tablesToTruncate = array('civicrm_contact', 'civicrm_uf_match');
 416       $this->quickCleanup($tablesToTruncate);
 417       $this->createDomainContacts();
 418     }
 419
 420     $this->cleanTempDirs();
 421     $this->unsetExtensionSystem();
 422   }
 423
 424   /**
 425    * Generic function to compare expected values after an api call to retrieved.
 426    * DB values.
 427    *
 428    * @daoName  string   DAO Name of object we're evaluating.
 429    * @id       int      Id of object
 430    * @match    array    Associative array of field name => expected value. Empty if asserting
 431    *                      that a DELETE occurred
 432    * @delete   boolean  True if we're checking that a DELETE action occurred.
 433    * @param $daoName
 434    * @param $id
 435    * @param $match
 436    * @param bool $delete
 437    * @throws \PHPUnit_Framework_AssertionFailedError
 438    */
 439   public function assertDBState($daoName, $id, $match, $delete = FALSE) {
 440     if (empty($id)) {
 441       // adding this here since developers forget to check for an id
 442       // and hence we get the first value in the db
 443       $this->fail('ID not populated. Please fix your assertDBState usage!!!');
 444     }
 445
 446     $object = new $daoName();
 447     $object->id = $id;
 448     $verifiedCount = 0;
 449
 450     // If we're asserting successful record deletion, make sure object is NOT found.
 451     if ($delete) {
 452       if ($object->find(TRUE)) {
 453         $this->fail("Object not deleted by delete operation: $daoName, $id");
 454       }
 455       return;
 456     }
 457
 458     // Otherwise check matches of DAO field values against expected values in $match.
 459     if ($object->find(TRUE)) {
 460       $fields = &$object->fields();
 461       foreach ($fields as $name => $value) {
 462         $dbName = $value['name'];
 463         if (isset($match[$name])) {
 464           $verifiedCount++;
 465           $this->assertEquals($object->$dbName, $match[$name]);
 466         }
 467         elseif (isset($match[$dbName])) {
 468           $verifiedCount++;
 469           $this->assertEquals($object->$dbName, $match[$dbName]);
 470         }
 471       }
 472     }
 473     else {
 474       $this->fail("Could not retrieve object: $daoName, $id");
 475     }
 476     $object->free();
 477     $matchSize = count($match);
 478     if ($verifiedCount != $matchSize) {
 479       $this->fail("Did not verify all fields in match array: $daoName, $id. Verified count = $verifiedCount. Match array size = $matchSize");
 480     }
 481   }
 482
 483   /**
 484    * Request a record from the DB by seachColumn+searchValue. Success if a record is found.
 485    * @param string $daoName
 486    * @param $searchValue
 487    * @param $returnColumn
 488    * @param $searchColumn
 489    * @param $message
 490    *
 491    * @return null|string
 492    * @throws PHPUnit_Framework_AssertionFailedError
 493    */
 494   public function assertDBNotNull($daoName, $searchValue, $returnColumn, $searchColumn, $message) {
 495     if (empty($searchValue)) {
 496       $this->fail("empty value passed to assertDBNotNull");
 497     }
 498     $value = CRM_Core_DAO::getFieldValue($daoName, $searchValue, $returnColumn, $searchColumn, TRUE);
 499     $this->assertNotNull($value, $message);
 500
 501     return $value;
 502   }
 503
 504   /**
 505    * Request a record from the DB by seachColumn+searchValue. Success if returnColumn value is NULL.
 506    * @param string $daoName
 507    * @param $searchValue
 508    * @param $returnColumn
 509    * @param $searchColumn
 510    * @param $message
 511    */
 512   public function assertDBNull($daoName, $searchValue, $returnColumn, $searchColumn, $message) {
 513     $value = CRM_Core_DAO::getFieldValue($daoName, $searchValue, $returnColumn, $searchColumn, TRUE);
 514     $this->assertNull($value, $message);
 515   }
 516
 517   /**
 518    * Request a record from the DB by id. Success if row not found.
 519    * @param string $daoName
 520    * @param int $id
 521    * @param null $message
 522    */
 523   public function assertDBRowNotExist($daoName, $id, $message = NULL) {
 524     $message = $message ? $message : "$daoName (#$id) should not exist";
 525     $value = CRM_Core_DAO::getFieldValue($daoName, $id, 'id', 'id', TRUE);
 526     $this->assertNull($value, $message);
 527   }
 528
 529   /**
 530    * Request a record from the DB by id. Success if row not found.
 531    * @param string $daoName
 532    * @param int $id
 533    * @param null $message
 534    */
 535   public function assertDBRowExist($daoName, $id, $message = NULL) {
 536     $message = $message ? $message : "$daoName (#$id) should exist";
 537     $value = CRM_Core_DAO::getFieldValue($daoName, $id, 'id', 'id', TRUE);
 538     $this->assertEquals($id, $value, $message);
 539   }
 540
 541   /**
 542    * Compare a single column value in a retrieved DB record to an expected value.
 543    * @param string $daoName
 544    * @param $searchValue
 545    * @param $returnColumn
 546    * @param $searchColumn
 547    * @param $expectedValue
 548    * @param $message
 549    */
 550   public function assertDBCompareValue(
 551     $daoName, $searchValue, $returnColumn, $searchColumn,
 552     $expectedValue, $message
 553   ) {
 554     $value = CRM_Core_DAO::getFieldValue($daoName, $searchValue, $returnColumn, $searchColumn, TRUE);
 555     $this->assertEquals($value, $expectedValue, $message);
 556   }
 557
 558   /**
 559    * Compare all values in a single retrieved DB record to an array of expected values.
 560    * @param string $daoName
 561    * @param array $searchParams
 562    * @param $expectedValues
 563    */
 564   public function assertDBCompareValues($daoName, $searchParams, $expectedValues) {
 565     //get the values from db
 566     $dbValues = array();
 567     CRM_Core_DAO::commonRetrieve($daoName, $searchParams, $dbValues);
 568
 569     // compare db values with expected values
 570     self::assertAttributesEquals($expectedValues, $dbValues);
 571   }
 572
 573   /**
 574    * Assert that a SQL query returns a given value.
 575    *
 576    * The first argument is an expected value. The remaining arguments are passed
 577    * to CRM_Core_DAO::singleValueQuery
 578    *
 579    * Example: $this->assertSql(2, 'select count(*) from foo where foo.bar like "%1"',
 580    * array(1 => array("Whiz", "String")));
 581    * @param $expected
 582    * @param $query
 583    * @param array $params
 584    * @param string $message
 585    */
 586   public function assertDBQuery($expected, $query, $params = array(), $message = '') {
 587     if ($message) {
 588       $message .= ': ';
 589     }
 590     $actual = CRM_Core_DAO::singleValueQuery($query, $params);
 591     $this->assertEquals($expected, $actual,
 592       sprintf('%sexpected=[%s] actual=[%s] query=[%s]',
 593         $message, $expected, $actual, CRM_Core_DAO::composeQuery($query, $params, FALSE)
 594       )
 595     );
 596   }
 597
 598   /**
 599    * Assert that two array-trees are exactly equal, notwithstanding
 600    * the sorting of keys
 601    *
 602    * @param array $expected
 603    * @param array $actual
 604    */
 605   public function assertTreeEquals($expected, $actual) {
 606     $e = array();
 607     $a = array();
 608     CRM_Utils_Array::flatten($expected, $e, '', ':::');
 609     CRM_Utils_Array::flatten($actual, $a, '', ':::');
 610     ksort($e);
 611     ksort($a);
 612
 613     $this->assertEquals($e, $a);
 614   }
 615
 616   /**
 617    * Assert that two numbers are approximately equal.
 618    *
 619    * @param int|float $expected
 620    * @param int|float $actual
 621    * @param int|float $tolerance
 622    * @param string $message
 623    */
 624   public function assertApproxEquals($expected, $actual, $tolerance, $message = NULL) {
 625     if ($message === NULL) {
 626       $message = sprintf("approx-equals: expected=[%.3f] actual=[%.3f] tolerance=[%.3f]", $expected, $actual, $tolerance);
 627     }
 628     $this->assertTrue(abs($actual - $expected) < $tolerance, $message);
 629   }
 630
 631   /**
 632    * Assert attributes are equal.
 633    *
 634    * @param $expectedValues
 635    * @param $actualValues
 636    * @param string $message
 637    *
 638    * @throws PHPUnit_Framework_AssertionFailedError
 639    */
 640   public function assertAttributesEquals($expectedValues, $actualValues, $message = NULL) {
 641     foreach ($expectedValues as $paramName => $paramValue) {
 642       if (isset($actualValues[$paramName])) {
 643         $this->assertEquals($paramValue, $actualValues[$paramName], "Value Mismatch On $paramName - value 1 is " . print_r($paramValue, TRUE) . "  value 2 is " . print_r($actualValues[$paramName], TRUE));
 644       }
 645       else {
 646         $this->assertNull($expectedValues[$paramName], "Attribute '$paramName' not present in actual array and we expected it to be " . $expectedValues[$paramName]);
 647       }
 648     }
 649   }
 650
 651   /**
 652    * @param $key
 653    * @param $list
 654    */
 655   public function assertArrayKeyExists($key, &$list) {
 656     $result = isset($list[$key]) ? TRUE : FALSE;
 657     $this->assertTrue($result, ts("%1 element exists?",
 658       array(1 => $key)
 659     ));
 660   }
 661
 662   /**
 663    * @param $key
 664    * @param $list
 665    */
 666   public function assertArrayValueNotNull($key, &$list) {
 667     $this->assertArrayKeyExists($key, $list);
 668
 669     $value = isset($list[$key]) ? $list[$key] : NULL;
 670     $this->assertTrue($value,
 671       ts("%1 element not null?",
 672         array(1 => $key)
 673       )
 674     );
 675   }
 676
 677   /**
 678    * Check that api returned 'is_error' => 0.
 679    *
 680    * @param array $apiResult
 681    *   Api result.
 682    * @param string $prefix
 683    *   Extra test to add to message.
 684    */
 685   public function assertAPISuccess($apiResult, $prefix = '') {
 686     if (!empty($prefix)) {
 687       $prefix .= ': ';
 688     }
 689     $errorMessage = empty($apiResult['error_message']) ? '' : " " . $apiResult['error_message'];
 690
 691     if (!empty($apiResult['debug_information'])) {
 692       $errorMessage .= "\n " . print_r($apiResult['debug_information'], TRUE);
 693     }
 694     if (!empty($apiResult['trace'])) {
 695       $errorMessage .= "\n" . print_r($apiResult['trace'], TRUE);
 696     }
 697     $this->assertEquals(0, $apiResult['is_error'], $prefix . $errorMessage);
 698   }
 699
 700   /**
 701    * Check that api returned 'is_error' => 1.
 702    *
 703    * @param array $apiResult
 704    *   Api result.
 705    * @param string $prefix
 706    *   Extra test to add to message.
 707    * @param null $expectedError
 708    */
 709   public function assertAPIFailure($apiResult, $prefix = '', $expectedError = NULL) {
 710     if (!empty($prefix)) {
 711       $prefix .= ': ';
 712     }
 713     if ($expectedError && !empty($apiResult['is_error'])) {
 714       $this->assertEquals($expectedError, $apiResult['error_message'], 'api error message not as expected' . $prefix);
 715     }
 716     $this->assertEquals(1, $apiResult['is_error'], "api call should have failed but it succeeded " . $prefix . (print_r($apiResult, TRUE)));
 717     $this->assertNotEmpty($apiResult['error_message']);
 718   }
 719
 720   /**
 721    * @param $expected
 722    * @param $actual
 723    * @param string $message
 724    */
 725   public function assertType($expected, $actual, $message = '') {
 726     return $this->assertInternalType($expected, $actual, $message);
 727   }
 728
 729   /**
 730    * Check that a deleted item has been deleted.
 731    *
 732    * @param $entity
 733    * @param $id
 734    */
 735   public function assertAPIDeleted($entity, $id) {
 736     $this->callAPISuccess($entity, 'getcount', array('id' => $id), 0);
 737   }
 738
 739
 740   /**
 741    * Check that api returned 'is_error' => 1
 742    * else provide full message
 743    * @param array $result
 744    * @param $expected
 745    * @param array $valuesToExclude
 746    * @param string $prefix
 747    *   Extra test to add to message.
 748    */
 749   public function assertAPIArrayComparison($result, $expected, $valuesToExclude = array(), $prefix = '') {
 750     $valuesToExclude = array_merge($valuesToExclude, array('debug', 'xdebug', 'sequential'));
 751     foreach ($valuesToExclude as $value) {
 752       if (isset($result[$value])) {
 753         unset($result[$value]);
 754       }
 755       if (isset($expected[$value])) {
 756         unset($expected[$value]);
 757       }
 758     }
 759     $this->assertEquals($result, $expected, "api result array comparison failed " . $prefix . print_r($result, TRUE) . ' was compared to ' . print_r($expected, TRUE));
 760   }
 761
 762   /**
 763    * A stub for the API interface. This can be overriden by subclasses to change how the API is called.
 764    *
 765    * @param $entity
 766    * @param $action
 767    * @param array $params
 768    * @return array|int
 769    */
 770   public function civicrm_api($entity, $action, $params) {
 771     return civicrm_api($entity, $action, $params);
 772   }
 773
 774   /**
 775    * Create a batch of external API calls which can
 776    * be executed concurrently.
 777    *
 778    * @code
 779    * $calls = $this->createExternalAPI()
 780    *    ->addCall('Contact', 'get', ...)
 781    *    ->addCall('Contact', 'get', ...)
 782    *    ...
 783    *    ->run()
 784    *    ->getResults();
 785    * @endcode
 786    *
 787    * @return \Civi\API\ExternalBatch
 788    * @throws PHPUnit_Framework_SkippedTestError
 789    */
 790   public function createExternalAPI() {
 791     global $civicrm_root;
 792     $defaultParams = array(
 793       'version' => $this->_apiversion,
 794       'debug' => 1,
 795     );
 796
 797     $calls = new \Civi\API\ExternalBatch($defaultParams);
 798
 799     if (!$calls->isSupported()) {
 800       $this->markTestSkipped('The test relies on Civi\API\ExternalBatch. This is unsupported in the local environment.');
 801     }
 802
 803     return $calls;
 804   }
 805
 806   /**
 807    * wrap api functions.
 808    * so we can ensure they succeed & throw exceptions without litterering the test with checks
 809    *
 810    * @param string $entity
 811    * @param string $action
 812    * @param array $params
 813    * @param mixed $checkAgainst
 814    *   Optional value to check result against, implemented for getvalue,.
 815    *   getcount, getsingle. Note that for getvalue the type is checked rather than the value
 816    *   for getsingle the array is compared against an array passed in - the id is not compared (for
 817    *   better or worse )
 818    *
 819    * @return array|int
 820    */
 821   public function callAPISuccess($entity, $action, $params, $checkAgainst = NULL) {
 822     $params = array_merge(array(
 823         'version' => $this->_apiversion,
 824         'debug' => 1,
 825       ),
 826       $params
 827     );
 828     switch (strtolower($action)) {
 829       case 'getvalue':
 830         return $this->callAPISuccessGetValue($entity, $params, $checkAgainst);
 831
 832       case 'getsingle':
 833         return $this->callAPISuccessGetSingle($entity, $params, $checkAgainst);
 834
 835       case 'getcount':
 836         return $this->callAPISuccessGetCount($entity, $params, $checkAgainst);
 837     }
 838     $result = $this->civicrm_api($entity, $action, $params);
 839     $this->assertAPISuccess($result, "Failure in api call for $entity $action");
 840     return $result;
 841   }
 842
 843   /**
 844    * This function exists to wrap api getValue function & check the result
 845    * so we can ensure they succeed & throw exceptions without litterering the test with checks
 846    * There is a type check in this
 847    *
 848    * @param string $entity
 849    * @param array $params
 850    * @param string $type
 851    *   Per http://php.net/manual/en/function.gettype.php possible types.
 852    *   - boolean
 853    *   - integer
 854    *   - double
 855    *   - string
 856    *   - array
 857    *   - object
 858    *
 859    * @return array|int
 860    */
 861   public function callAPISuccessGetValue($entity, $params, $type = NULL) {
 862     $params += array(
 863       'version' => $this->_apiversion,
 864       'debug' => 1,
 865     );
 866     $result = $this->civicrm_api($entity, 'getvalue', $params);
 867     if ($type) {
 868       if ($type == 'integer') {
 869         // api seems to return integers as strings
 870         $this->assertTrue(is_numeric($result), "expected a numeric value but got " . print_r($result, 1));
 871       }
 872       else {
 873         $this->assertType($type, $result, "returned result should have been of type $type but was ");
 874       }
 875     }
 876     return $result;
 877   }
 878
 879   /**
 880    * This function exists to wrap api getsingle function & check the result
 881    * so we can ensure they succeed & throw exceptions without litterering the test with checks
 882    *
 883    * @param string $entity
 884    * @param array $params
 885    * @param array $checkAgainst
 886    *   Array to compare result against.
 887    *   - boolean
 888    *   - integer
 889    *   - double
 890    *   - string
 891    *   - array
 892    *   - object
 893    *
 894    * @throws Exception
 895    * @return array|int
 896    */
 897   public function callAPISuccessGetSingle($entity, $params, $checkAgainst = NULL) {
 898     $params += array(
 899       'version' => $this->_apiversion,
 900       'debug' => 1,
 901     );
 902     $result = $this->civicrm_api($entity, 'getsingle', $params);
 903     if (!is_array($result) || !empty($result['is_error']) || isset($result['values'])) {
 904       throw new Exception('Invalid getsingle result' . print_r($result, TRUE));
 905     }
 906     if ($checkAgainst) {
 907       // @todo - have gone with the fn that unsets id? should we check id?
 908       $this->checkArrayEquals($result, $checkAgainst);
 909     }
 910     return $result;
 911   }
 912
 913   /**
 914    * This function exists to wrap api getValue function & check the result
 915    * so we can ensure they succeed & throw exceptions without litterering the test with checks
 916    * There is a type check in this
 917    * @param string $entity
 918    * @param array $params
 919    * @param null $count
 920    * @throws Exception
 921    * @return array|int
 922    */
 923   public function callAPISuccessGetCount($entity, $params, $count = NULL) {
 924     $params += array(
 925       'version' => $this->_apiversion,
 926       'debug' => 1,
 927     );
 928     $result = $this->civicrm_api($entity, 'getcount', $params);
 929     if (!is_int($result) || !empty($result['is_error']) || isset($result['values'])) {
 930       throw new Exception('Invalid getcount result : ' . print_r($result, TRUE) . " type :" . gettype($result));
 931     }
 932     if (is_int($count)) {
 933       $this->assertEquals($count, $result, "incorrect count returned from $entity getcount");
 934     }
 935     return $result;
 936   }
 937
 938   /**
 939    * This function exists to wrap api functions.
 940    * so we can ensure they succeed, generate and example & throw exceptions without litterering the test with checks
 941    *
 942    * @param string $entity
 943    * @param string $action
 944    * @param array $params
 945    * @param string $function
 946    *   Pass this in to create a generated example.
 947    * @param string $file
 948    *   Pass this in to create a generated example.
 949    * @param string $description
 950    * @param string|null $exampleName
 951    *
 952    * @return array|int
 953    */
 954   public function callAPIAndDocument($entity, $action, $params, $function, $file, $description = "", $exampleName = NULL) {
 955     $params['version'] = $this->_apiversion;
 956     $result = $this->callAPISuccess($entity, $action, $params);
 957     $this->documentMe($entity, $action, $params, $result, $function, $file, $description, $exampleName);
 958     return $result;
 959   }
 960
 961   /**
 962    * This function exists to wrap api functions.
 963    * so we can ensure they fail where expected & throw exceptions without litterering the test with checks
 964    * @param string $entity
 965    * @param string $action
 966    * @param array $params
 967    * @param string $expectedErrorMessage
 968    *   Error.
 969    * @param null $extraOutput
 970    * @return array|int
 971    */
 972   public function callAPIFailure($entity, $action, $params, $expectedErrorMessage = NULL, $extraOutput = NULL) {
 973     if (is_array($params)) {
 974       $params += array(
 975         'version' => $this->_apiversion,
 976       );
 977     }
 978     $result = $this->civicrm_api($entity, $action, $params);
 979     $this->assertAPIFailure($result, "We expected a failure for $entity $action but got a success", $expectedErrorMessage);
 980     return $result;
 981   }
 982
 983   /**
 984    * Create required data based on $this->entity & $this->params
 985    * This is just a way to set up the test data for delete & get functions
 986    * so the distinction between set
 987    * up & tested functions is clearer
 988    *
 989    * @return array
 990    *   api Result
 991    */
 992   public function createTestEntity() {
 993     return $entity = $this->callAPISuccess($this->entity, 'create', $this->params);
 994   }
 995
 996   /**
 997    * Generic function to create Organisation, to be used in test cases
 998    *
 999    * @param array $params
1000    *   parameters for civicrm_contact_add api function call
1001    * @param int $seq
1002    *   sequence number if creating multiple organizations
1003    *
1004    * @return int
1005    *   id of Organisation created
1006    */
1007   public function organizationCreate($params = array(), $seq = 0) {
1008     if (!$params) {
1009       $params = array();
1010     }
1011     $params = array_merge($this->sampleContact('Organization', $seq), $params);
1012     return $this->_contactCreate($params);
1013   }
1014
1015   /**
1016    * Generic function to create Individual, to be used in test cases
1017    *
1018    * @param array $params
1019    *   parameters for civicrm_contact_add api function call
1020    * @param int $seq
1021    *   sequence number if creating multiple individuals
1022    *
1023    * @return int
1024    *   id of Individual created
1025    */
1026   public function individualCreate($params = array(), $seq = 0) {
1027     $params = array_merge($this->sampleContact('Individual', $seq), $params);
1028     return $this->_contactCreate($params);
1029   }
1030
1031   /**
1032    * Generic function to create Household, to be used in test cases
1033    *
1034    * @param array $params
1035    *   parameters for civicrm_contact_add api function call
1036    * @param int $seq
1037    *   sequence number if creating multiple households
1038    *
1039    * @return int
1040    *   id of Household created
1041    */
1042   public function householdCreate($params = array(), $seq = 0) {
1043     $params = array_merge($this->sampleContact('Household', $seq), $params);
1044     return $this->_contactCreate($params);
1045   }
1046
1047   /**
1048    * Helper function for getting sample contact properties.
1049    *
1050    * @param string $contact_type
1051    *   enum contact type: Individual, Organization
1052    * @param int $seq
1053    *   sequence number for the values of this type
1054    *
1055    * @return array
1056    *   properties of sample contact (ie. $params for API call)
1057    */
1058   public function sampleContact($contact_type, $seq = 0) {
1059     $samples = array(
1060       'Individual' => array(
1061         // The number of values in each list need to be coprime numbers to not have duplicates
1062         'first_name' => array('Anthony', 'Joe', 'Terrence', 'Lucie', 'Albert', 'Bill', 'Kim'),
1063         'middle_name' => array('J.', 'M.', 'P', 'L.', 'K.', 'A.', 'B.', 'C.', 'D', 'E.', 'Z.'),
1064         'last_name' => array('Anderson', 'Miller', 'Smith', 'Collins', 'Peterson'),
1065       ),
1066       'Organization' => array(
1067         'organization_name' => array(
1068           'Unit Test Organization',
1069           'Acme',
1070           'Roberts and Sons',
1071           'Cryo Space Labs',
1072           'Sharper Pens',
1073         ),
1074       ),
1075       'Household' => array(
1076         'household_name' => array('Unit Test household'),
1077       ),
1078     );
1079     $params = array('contact_type' => $contact_type);
1080     foreach ($samples[$contact_type] as $key => $values) {
1081       $params[$key] = $values[$seq % count($values)];
1082     }
1083     if ($contact_type == 'Individual') {
1084       $params['email'] = strtolower(
1085         $params['first_name'] . '_' . $params['last_name'] . '@civicrm.org'
1086       );
1087       $params['prefix_id'] = 3;
1088       $params['suffix_id'] = 3;
1089     }
1090     return $params;
1091   }
1092
1093   /**
1094    * Private helper function for calling civicrm_contact_add.
1095    *
1096    * @param array $params
1097    *   For civicrm_contact_add api function call.
1098    *
1099    * @throws Exception
1100    *
1101    * @return int
1102    *   id of Household created
1103    */
1104   private function _contactCreate($params) {
1105     $result = $this->callAPISuccess('contact', 'create', $params);
1106     if (!empty($result['is_error']) || empty($result['id'])) {
1107       throw new Exception('Could not create test contact, with message: ' . CRM_Utils_Array::value('error_message', $result) . "\nBacktrace:" . CRM_Utils_Array::value('trace', $result));
1108     }
1109     return $result['id'];
1110   }
1111
1112   /**
1113    * Delete contact, ensuring it is not the domain contact
1114    *
1115    * @param int $contactID
1116    *   Contact ID to delete
1117    */
1118   public function contactDelete($contactID) {
1119     $domain = new CRM_Core_BAO_Domain();
1120     $domain->contact_id = $contactID;
1121     if (!$domain->find(TRUE)) {
1122       $this->callAPISuccess('contact', 'delete', array(
1123         'id' => $contactID,
1124         'skip_undelete' => 1,
1125       ));
1126     }
1127   }
1128
1129   /**
1130    * @param int $contactTypeId
1131    *
1132    * @throws Exception
1133    */
1134   public function contactTypeDelete($contactTypeId) {
1135     $result = CRM_Contact_BAO_ContactType::del($contactTypeId);
1136     if (!$result) {
1137       throw new Exception('Could not delete contact type');
1138     }
1139   }
1140
1141   /**
1142    * @param array $params
1143    *
1144    * @return mixed
1145    */
1146   public function membershipTypeCreate($params = array()) {
1147     CRM_Member_PseudoConstant::flush('membershipType');
1148     CRM_Core_Config::clearDBCache();
1149     $this->setupIDs['contact'] = $memberOfOrganization = $this->organizationCreate();
1150     $params = array_merge(array(
1151       'name' => 'General',
1152       'duration_unit' => 'year',
1153       'duration_interval' => 1,
1154       'period_type' => 'rolling',
1155       'member_of_contact_id' => $memberOfOrganization,
1156       'domain_id' => 1,
1157       'financial_type_id' => 2,
1158       'is_active' => 1,
1159       'sequential' => 1,
1160       'visibility' => 'Public',
1161     ), $params);
1162
1163     $result = $this->callAPISuccess('MembershipType', 'Create', $params);
1164
1165     CRM_Member_PseudoConstant::flush('membershipType');
1166     CRM_Utils_Cache::singleton()->flush();
1167
1168     return $result['id'];
1169   }
1170
1171   /**
1172    * @param array $params
1173    *
1174    * @return mixed
1175    */
1176   public function contactMembershipCreate($params) {
1177     $params = array_merge(array(
1178       'join_date' => '2007-01-21',
1179       'start_date' => '2007-01-21',
1180       'end_date' => '2007-12-21',
1181       'source' => 'Payment',
1182       'membership_type_id' => 'General',
1183     ), $params);
1184     if (!is_numeric($params['membership_type_id'])) {
1185       $membershipTypes = $this->callAPISuccess('Membership', 'getoptions', array('action' => 'create', 'field' => 'membership_type_id'));
1186       if (!in_array($params['membership_type_id'], $membershipTypes['values'])) {
1187         $this->membershipTypeCreate(array('name' => $params['membership_type_id']));
1188       }
1189     }
1190
1191     $result = $this->callAPISuccess('Membership', 'create', $params);
1192     return $result['id'];
1193   }
1194
1195   /**
1196    * Delete Membership Type.
1197    *
1198    * @param array $params
1199    */
1200   public function membershipTypeDelete($params) {
1201     $this->callAPISuccess('MembershipType', 'Delete', $params);
1202   }
1203
1204   /**
1205    * @param int $membershipID
1206    */
1207   public function membershipDelete($membershipID) {
1208     $deleteParams = array('id' => $membershipID);
1209     $result = $this->callAPISuccess('Membership', 'Delete', $deleteParams);
1210   }
1211
1212   /**
1213    * @param string $name
1214    *
1215    * @return mixed
1216    */
1217   public function membershipStatusCreate($name = 'test member status') {
1218     $params['name'] = $name;
1219     $params['start_event'] = 'start_date';
1220     $params['end_event'] = 'end_date';
1221     $params['is_current_member'] = 1;
1222     $params['is_active'] = 1;
1223
1224     $result = $this->callAPISuccess('MembershipStatus', 'Create', $params);
1225     CRM_Member_PseudoConstant::flush('membershipStatus');
1226     return $result['id'];
1227   }
1228
1229   /**
1230    * @param int $membershipStatusID
1231    */
1232   public function membershipStatusDelete($membershipStatusID) {
1233     if (!$membershipStatusID) {
1234       return;
1235     }
1236     $result = $this->callAPISuccess('MembershipStatus', 'Delete', array('id' => $membershipStatusID));
1237   }
1238
1239   /**
1240    * @param array $params
1241    *
1242    * @return mixed
1243    */
1244   public function relationshipTypeCreate($params = array()) {
1245     $params = array_merge(array(
1246         'name_a_b' => 'Relation 1 for relationship type create',
1247         'name_b_a' => 'Relation 2 for relationship type create',
1248         'contact_type_a' => 'Individual',
1249         'contact_type_b' => 'Organization',
1250         'is_reserved' => 1,
1251         'is_active' => 1,
1252       ),
1253       $params
1254     );
1255
1256     $result = $this->callAPISuccess('relationship_type', 'create', $params);
1257     CRM_Core_PseudoConstant::flush('relationshipType');
1258
1259     return $result['id'];
1260   }
1261
1262   /**
1263    * Delete Relatinship Type.
1264    *
1265    * @param int $relationshipTypeID
1266    */
1267   public function relationshipTypeDelete($relationshipTypeID) {
1268     $params['id'] = $relationshipTypeID;
1269     $this->callAPISuccess('relationship_type', 'delete', $params);
1270   }
1271
1272   /**
1273    * @param array $params
1274    *
1275    * @return mixed
1276    */
1277   public function paymentProcessorTypeCreate($params = NULL) {
1278     if (is_null($params)) {
1279       $params = array(
1280         'name' => 'API_Test_PP',
1281         'title' => 'API Test Payment Processor',
1282         'class_name' => 'CRM_Core_Payment_APITest',
1283         'billing_mode' => 'form',
1284         'is_recur' => 0,
1285         'is_reserved' => 1,
1286         'is_active' => 1,
1287       );
1288     }
1289     $result = $this->callAPISuccess('payment_processor_type', 'create', $params);
1290
1291     CRM_Core_PseudoConstant::flush('paymentProcessorType');
1292
1293     return $result['id'];
1294   }
1295
1296   /**
1297    * Create test Authorize.net instance.
1298    *
1299    * @param array $params
1300    *
1301    * @return mixed
1302    */
1303   public function paymentProcessorAuthorizeNetCreate($params = array()) {
1304     $params = array_merge(array(
1305       'name' => 'Authorize',
1306       'domain_id' => CRM_Core_Config::domainID(),
1307       'payment_processor_type_id' => 'AuthNet',
1308       'title' => 'AuthNet',
1309       'is_active' => 1,
1310       'is_default' => 0,
1311       'is_test' => 1,
1312       'is_recur' => 1,
1313       'user_name' => '4y5BfuW7jm',
1314       'password' => '4cAmW927n8uLf5J8',
1315       'url_site' => 'https://test.authorize.net/gateway/transact.dll',
1316       'url_recur' => 'https://apitest.authorize.net/xml/v1/request.api',
1317       'class_name' => 'Payment_AuthorizeNet',
1318       'billing_mode' => 1,
1319     ), $params);
1320
1321     $result = $this->callAPISuccess('PaymentProcessor', 'create', $params);
1322     return $result['id'];
1323   }
1324
1325   /**
1326    * Create Participant.
1327    *
1328    * @param array $params
1329    *   Array of contact id and event id values.
1330    *
1331    * @return int
1332    *   $id of participant created
1333    */
1334   public function participantCreate($params) {
1335     if (empty($params['contact_id'])) {
1336       $params['contact_id'] = $this->individualCreate();
1337     }
1338     if (empty($params['event_id'])) {
1339       $event = $this->eventCreate();
1340       $params['event_id'] = $event['id'];
1341     }
1342     $defaults = array(
1343       'status_id' => 2,
1344       'role_id' => 1,
1345       'register_date' => 20070219,
1346       'source' => 'Wimbeldon',
1347       'event_level' => 'Payment',
1348       'debug' => 1,
1349     );
1350
1351     $params = array_merge($defaults, $params);
1352     $result = $this->callAPISuccess('Participant', 'create', $params);
1353     return $result['id'];
1354   }
1355
1356   /**
1357    * Create Payment Processor.
1358    *
1359    * @return int
1360    *   Id Payment Processor
1361    */
1362   public function processorCreate() {
1363     $processorParams = array(
1364       'domain_id' => 1,
1365       'name' => 'Dummy',
1366       'payment_processor_type_id' => 'Dummy',
1367       'financial_account_id' => 12,
1368       'is_test' => TRUE,
1369       'is_active' => 1,
1370       'user_name' => '',
1371       'url_site' => 'http://dummy.com',
1372       'url_recur' => 'http://dummy.com',
1373       'billing_mode' => 1,
1374       'sequential' => 1,
1375     );
1376     $processor = $this->callAPISuccess('PaymentProcessor', 'create', $processorParams);
1377     return $processor['id'];
1378   }
1379
1380   /**
1381    * Create Payment Processor.
1382    *
1383    * @param array $processorParams
1384    *
1385    * @return \CRM_Core_Payment_Dummy
1386    *    Instance of Dummy Payment Processor
1387    */
1388   public function dummyProcessorCreate($processorParams = array()) {
1389     $paymentProcessorID = $this->processorCreate($processorParams);
1390     return System::singleton()->getById($paymentProcessorID);
1391   }
1392
1393   /**
1394    * Create contribution page.
1395    *
1396    * @param array $params
1397    * @return array
1398    *   Array of contribution page
1399    */
1400   public function contributionPageCreate($params = array()) {
1401     $this->_pageParams = array_merge(array(
1402       'title' => 'Test Contribution Page',
1403       'financial_type_id' => 1,
1404       'currency' => 'USD',
1405       'financial_account_id' => 1,
1406       'is_active' => 1,
1407       'is_allow_other_amount' => 1,
1408       'min_amount' => 10,
1409       'max_amount' => 1000,
1410     ), $params);
1411     return $this->callAPISuccess('contribution_page', 'create', $this->_pageParams);
1412   }
1413
1414   /**
1415    * Create a sample batch.
1416    */
1417   public function batchCreate() {
1418     $params = $this->_params;
1419     $params['name'] = $params['title'] = 'Batch_433397';
1420     $params['status_id'] = 1;
1421     $result = $this->callAPISuccess('batch', 'create', $params);
1422     return $result['id'];
1423   }
1424
1425   /**
1426    * Create Tag.
1427    *
1428    * @param array $params
1429    * @return array
1430    *   result of created tag
1431    */
1432   public function tagCreate($params = array()) {
1433     $defaults = array(
1434       'name' => 'New Tag3',
1435       'description' => 'This is description for Our New Tag ',
1436       'domain_id' => '1',
1437     );
1438     $params = array_merge($defaults, $params);
1439     $result = $this->callAPISuccess('Tag', 'create', $params);
1440     return $result['values'][$result['id']];
1441   }
1442
1443   /**
1444    * Delete Tag.
1445    *
1446    * @param int $tagId
1447    *   Id of the tag to be deleted.
1448    *
1449    * @return int
1450    */
1451   public function tagDelete($tagId) {
1452     require_once 'api/api.php';
1453     $params = array(
1454       'tag_id' => $tagId,
1455     );
1456     $result = $this->callAPISuccess('Tag', 'delete', $params);
1457     return $result['id'];
1458   }
1459
1460   /**
1461    * Add entity(s) to the tag
1462    *
1463    * @param array $params
1464    *
1465    * @return bool
1466    */
1467   public function entityTagAdd($params) {
1468     $result = $this->callAPISuccess('entity_tag', 'create', $params);
1469     return TRUE;
1470   }
1471
1472   /**
1473    * Create pledge.
1474    *
1475    * @param array $params
1476    *  Parameters.
1477    *
1478    * @return int
1479    *   id of created pledge
1480    */
1481   public function pledgeCreate($params) {
1482     $params = array_merge(array(
1483       'pledge_create_date' => date('Ymd'),
1484       'start_date' => date('Ymd'),
1485       'scheduled_date' => date('Ymd'),
1486       'amount' => 100.00,
1487       'pledge_status_id' => '2',
1488       'financial_type_id' => '1',
1489       'pledge_original_installment_amount' => 20,
1490       'frequency_interval' => 5,
1491       'frequency_unit' => 'year',
1492       'frequency_day' => 15,
1493       'installments' => 5,
1494     ),
1495     $params);
1496
1497     $result = $this->callAPISuccess('Pledge', 'create', $params);
1498     return $result['id'];
1499   }
1500
1501   /**
1502    * Delete contribution.
1503    *
1504    * @param int $pledgeId
1505    */
1506   public function pledgeDelete($pledgeId) {
1507     $params = array(
1508       'pledge_id' => $pledgeId,
1509     );
1510     $this->callAPISuccess('Pledge', 'delete', $params);
1511   }
1512
1513   /**
1514    * Create contribution.
1515    *
1516    * @param array $params
1517    *   Array of parameters.
1518    *
1519    * @return int
1520    *   id of created contribution
1521    */
1522   public function contributionCreate($params) {
1523
1524     $params = array_merge(array(
1525       'domain_id' => 1,
1526       'receive_date' => date('Ymd'),
1527       'total_amount' => 100.00,
1528       'fee_amount' => 5.00,
1529       'net_ammount' => 95.00,
1530       'financial_type_id' => 1,
1531       'payment_instrument_id' => 1,
1532       'non_deductible_amount' => 10.00,
1533       'trxn_id' => 12345,
1534       'invoice_id' => 67890,
1535       'source' => 'SSF',
1536       'contribution_status_id' => 1,
1537     ), $params);
1538
1539     $result = $this->callAPISuccess('contribution', 'create', $params);
1540     return $result['id'];
1541   }
1542
1543   /**
1544    * Delete contribution.
1545    *
1546    * @param int $contributionId
1547    *
1548    * @return array|int
1549    */
1550   public function contributionDelete($contributionId) {
1551     $params = array(
1552       'contribution_id' => $contributionId,
1553     );
1554     $result = $this->callAPISuccess('contribution', 'delete', $params);
1555     return $result;
1556   }
1557
1558   /**
1559    * Create an Event.
1560    *
1561    * @param array $params
1562    *   Name-value pair for an event.
1563    *
1564    * @return array
1565    */
1566   public function eventCreate($params = array()) {
1567     // if no contact was passed, make up a dummy event creator
1568     if (!isset($params['contact_id'])) {
1569       $params['contact_id'] = $this->_contactCreate(array(
1570         'contact_type' => 'Individual',
1571         'first_name' => 'Event',
1572         'last_name' => 'Creator',
1573       ));
1574     }
1575
1576     // set defaults for missing params
1577     $params = array_merge(array(
1578       'title' => 'Annual CiviCRM meet',
1579       'summary' => 'If you have any CiviCRM related issues or want to track where CiviCRM is heading, Sign up now',
1580       'description' => 'This event is intended to give brief idea about progess of CiviCRM and giving solutions to common user issues',
1581       'event_type_id' => 1,
1582       'is_public' => 1,
1583       'start_date' => 20081021,
1584       'end_date' => 20081023,
1585       'is_online_registration' => 1,
1586       'registration_start_date' => 20080601,
1587       'registration_end_date' => 20081015,
1588       'max_participants' => 100,
1589       'event_full_text' => 'Sorry! We are already full',
1590       'is_monetary' => 0,
1591       'is_active' => 1,
1592       'is_show_location' => 0,
1593     ), $params);
1594
1595     return $this->callAPISuccess('Event', 'create', $params);
1596   }
1597
1598   /**
1599    * Delete event.
1600    *
1601    * @param int $id
1602    *   ID of the event.
1603    *
1604    * @return array|int
1605    */
1606   public function eventDelete($id) {
1607     $params = array(
1608       'event_id' => $id,
1609     );
1610     return $this->callAPISuccess('event', 'delete', $params);
1611   }
1612
1613   /**
1614    * Delete participant.
1615    *
1616    * @param int $participantID
1617    *
1618    * @return array|int
1619    */
1620   public function participantDelete($participantID) {
1621     $params = array(
1622       'id' => $participantID,
1623     );
1624     return $this->callAPISuccess('Participant', 'delete', $params);
1625   }
1626
1627   /**
1628    * Create participant payment.
1629    *
1630    * @param int $participantID
1631    * @param int $contributionID
1632    * @return int
1633    *   $id of created payment
1634    */
1635   public function participantPaymentCreate($participantID, $contributionID = NULL) {
1636     //Create Participant Payment record With Values
1637     $params = array(
1638       'participant_id' => $participantID,
1639       'contribution_id' => $contributionID,
1640     );
1641
1642     $result = $this->callAPISuccess('participant_payment', 'create', $params);
1643     return $result['id'];
1644   }
1645
1646   /**
1647    * Delete participant payment.
1648    *
1649    * @param int $paymentID
1650    */
1651   public function participantPaymentDelete($paymentID) {
1652     $params = array(
1653       'id' => $paymentID,
1654     );
1655     $result = $this->callAPISuccess('participant_payment', 'delete', $params);
1656   }
1657
1658   /**
1659    * Add a Location.
1660    *
1661    * @param int $contactID
1662    * @return int
1663    *   location id of created location
1664    */
1665   public function locationAdd($contactID) {
1666     $address = array(
1667       1 => array(
1668         'location_type' => 'New Location Type',
1669         'is_primary' => 1,
1670         'name' => 'Saint Helier St',
1671         'county' => 'Marin',
1672         'country' => 'UNITED STATES',
1673         'state_province' => 'Michigan',
1674         'supplemental_address_1' => 'Hallmark Ct',
1675         'supplemental_address_2' => 'Jersey Village',
1676       ),
1677     );
1678
1679     $params = array(
1680       'contact_id' => $contactID,
1681       'address' => $address,
1682       'location_format' => '2.0',
1683       'location_type' => 'New Location Type',
1684     );
1685
1686     $result = $this->callAPISuccess('Location', 'create', $params);
1687     return $result;
1688   }
1689
1690   /**
1691    * Delete Locations of contact.
1692    *
1693    * @param array $params
1694    *   Parameters.
1695    */
1696   public function locationDelete($params) {
1697     $this->callAPISuccess('Location', 'delete', $params);
1698   }
1699
1700   /**
1701    * Add a Location Type.
1702    *
1703    * @param array $params
1704    * @return CRM_Core_DAO_LocationType
1705    *   location id of created location
1706    */
1707   public function locationTypeCreate($params = NULL) {
1708     if ($params === NULL) {
1709       $params = array(
1710         'name' => 'New Location Type',
1711         'vcard_name' => 'New Location Type',
1712         'description' => 'Location Type for Delete',
1713         'is_active' => 1,
1714       );
1715     }
1716
1717     $locationType = new CRM_Core_DAO_LocationType();
1718     $locationType->copyValues($params);
1719     $locationType->save();
1720     // clear getfields cache
1721     CRM_Core_PseudoConstant::flush();
1722     $this->callAPISuccess('phone', 'getfields', array('version' => 3, 'cache_clear' => 1));
1723     return $locationType;
1724   }
1725
1726   /**
1727    * Delete a Location Type.
1728    *
1729    * @param int $locationTypeId
1730    */
1731   public function locationTypeDelete($locationTypeId) {
1732     $locationType = new CRM_Core_DAO_LocationType();
1733     $locationType->id = $locationTypeId;
1734     $locationType->delete();
1735   }
1736
1737   /**
1738    * Add a Mapping.
1739    *
1740    * @param array $params
1741    * @return CRM_Core_DAO_Mapping
1742    *   Mapping id of created mapping
1743    */
1744   public function mappingCreate($params = NULL) {
1745     if ($params === NULL) {
1746       $params = array(
1747         'name' => 'Mapping name',
1748         'description' => 'Mapping description',
1749         // 'Export Contact' mapping.
1750         'mapping_type_id' => 7,
1751       );
1752     }
1753
1754     $mapping = new CRM_Core_DAO_Mapping();
1755     $mapping->copyValues($params);
1756     $mapping->save();
1757     // clear getfields cache
1758     CRM_Core_PseudoConstant::flush();
1759     $this->callAPISuccess('mapping', 'getfields', array('version' => 3, 'cache_clear' => 1));
1760     return $mapping;
1761   }
1762
1763   /**
1764    * Delete a Mapping
1765    *
1766    * @param int $mappingId
1767    */
1768   public function mappingDelete($mappingId) {
1769     $mapping = new CRM_Core_DAO_Mapping();
1770     $mapping->id = $mappingId;
1771     $mapping->delete();
1772   }
1773
1774   /**
1775    * Add a Group.
1776    *
1777    * @param array $params
1778    * @return int
1779    *   groupId of created group
1780    */
1781   public function groupCreate($params = array()) {
1782     $params = array_merge(array(
1783       'name' => 'Test Group 1',
1784       'domain_id' => 1,
1785       'title' => 'New Test Group Created',
1786       'description' => 'New Test Group Created',
1787       'is_active' => 1,
1788       'visibility' => 'Public Pages',
1789       'group_type' => array(
1790         '1' => 1,
1791         '2' => 1,
1792       ),
1793     ), $params);
1794
1795     $result = $this->callAPISuccess('Group', 'create', $params);
1796     return $result['id'];
1797   }
1798
1799   /**
1800    * Create a smart group.
1801    *
1802    * By default it will be a group of households.
1803    *
1804    * @param array $smartGroupParams
1805    * @param array $groupParams
1806    * @return int
1807    */
1808   public function smartGroupCreate($smartGroupParams = array(), $groupParams = array()) {
1809     $smartGroupParams = array_merge(array(
1810       'formValues' => array('contact_type' => array('IN' => array('Household'))),
1811     ),
1812     $smartGroupParams);
1813     $savedSearch = CRM_Contact_BAO_SavedSearch::create($smartGroupParams);
1814
1815     $groupParams['saved_search_id'] = $savedSearch->id;
1816     return $this->groupCreate($groupParams);
1817   }
1818
1819   /**
1820    * Function to add a Group.
1821    *
1822    * @params array to add group
1823    *
1824    * @param int $groupID
1825    * @param int $totalCount
1826    * @return int
1827    *    groupId of created group
1828    */
1829   public function groupContactCreate($groupID, $totalCount = 10) {
1830     $params = array('group_id' => $groupID);
1831     for ($i = 1; $i <= $totalCount; $i++) {
1832       $contactID = $this->individualCreate();
1833       if ($i == 1) {
1834         $params += array('contact_id' => $contactID);
1835       }
1836       else {
1837         $params += array("contact_id.$i" => $contactID);
1838       }
1839     }
1840     $result = $this->callAPISuccess('GroupContact', 'create', $params);
1841
1842     return $result;
1843   }
1844
1845   /**
1846    * Delete a Group.
1847    *
1848    * @param int $gid
1849    */
1850   public function groupDelete($gid) {
1851
1852     $params = array(
1853       'id' => $gid,
1854     );
1855
1856     $this->callAPISuccess('Group', 'delete', $params);
1857   }
1858
1859   /**
1860    * Create a UFField.
1861    * @param array $params
1862    */
1863   public function uFFieldCreate($params = array()) {
1864     $params = array_merge(array(
1865       'uf_group_id' => 1,
1866       'field_name' => 'first_name',
1867       'is_active' => 1,
1868       'is_required' => 1,
1869       'visibility' => 'Public Pages and Listings',
1870       'is_searchable' => '1',
1871       'label' => 'first_name',
1872       'field_type' => 'Individual',
1873       'weight' => 1,
1874     ), $params);
1875     $this->callAPISuccess('uf_field', 'create', $params);
1876   }
1877
1878   /**
1879    * Add a UF Join Entry.
1880    *
1881    * @param array $params
1882    * @return int
1883    *   $id of created UF Join
1884    */
1885   public function ufjoinCreate($params = NULL) {
1886     if ($params === NULL) {
1887       $params = array(
1888         'is_active' => 1,
1889         'module' => 'CiviEvent',
1890         'entity_table' => 'civicrm_event',
1891         'entity_id' => 3,
1892         'weight' => 1,
1893         'uf_group_id' => 1,
1894       );
1895     }
1896     $result = $this->callAPISuccess('uf_join', 'create', $params);
1897     return $result;
1898   }
1899
1900   /**
1901    * Delete a UF Join Entry.
1902    *
1903    * @param array $params
1904    *   with missing uf_group_id
1905    */
1906   public function ufjoinDelete($params = NULL) {
1907     if ($params === NULL) {
1908       $params = array(
1909         'is_active' => 1,
1910         'module' => 'CiviEvent',
1911         'entity_table' => 'civicrm_event',
1912         'entity_id' => 3,
1913         'weight' => 1,
1914         'uf_group_id' => '',
1915       );
1916     }
1917
1918     crm_add_uf_join($params);
1919   }
1920
1921   /**
1922    * @param array $params
1923    *   Optional parameters.
1924    *
1925    * @return int
1926    *   Campaign ID.
1927    */
1928   public function campaignCreate($params = array()) {
1929     $this->enableCiviCampaign();
1930     $campaign = $this->callAPISuccess('campaign', 'create', array_merge(array(
1931       'name' => 'big_campaign',
1932       'title' => 'Campaign',
1933     ), $params));
1934     return $campaign['id'];
1935   }
1936
1937   /**
1938    * Create Group for a contact.
1939    *
1940    * @param int $contactId
1941    */
1942   public function contactGroupCreate($contactId) {
1943     $params = array(
1944       'contact_id.1' => $contactId,
1945       'group_id' => 1,
1946     );
1947
1948     $this->callAPISuccess('GroupContact', 'Create', $params);
1949   }
1950
1951   /**
1952    * Delete Group for a contact.
1953    *
1954    * @param int $contactId
1955    */
1956   public function contactGroupDelete($contactId) {
1957     $params = array(
1958       'contact_id.1' => $contactId,
1959       'group_id' => 1,
1960     );
1961     $this->civicrm_api('GroupContact', 'Delete', $params);
1962   }
1963
1964   /**
1965    * Create Activity.
1966    *
1967    * @param array $params
1968    * @return array|int
1969    */
1970   public function activityCreate($params = array()) {
1971     $params = array_merge(array(
1972       'subject' => 'Discussion on warm beer',
1973       'activity_date_time' => date('Ymd'),
1974       'duration_hours' => 30,
1975       'duration_minutes' => 20,
1976       'location' => 'Baker Street',
1977       'details' => 'Lets schedule a meeting',
1978       'status_id' => 1,
1979       'activity_name' => 'Meeting',
1980     ), $params);
1981     if (!isset($params['source_contact_id'])) {
1982       $params['source_contact_id'] = $this->individualCreate();
1983     }
1984     if (!isset($params['target_contact_id'])) {
1985       $params['target_contact_id'] = $this->individualCreate(array(
1986         'first_name' => 'Julia',
1987         'Last_name' => 'Anderson',
1988         'prefix' => 'Ms.',
1989         'email' => 'julia_anderson@civicrm.org',
1990         'contact_type' => 'Individual',
1991       ));
1992     }
1993     if (!isset($params['assignee_contact_id'])) {
1994       $params['assignee_contact_id'] = $params['target_contact_id'];
1995     }
1996
1997     $result = $this->callAPISuccess('Activity', 'create', $params);
1998
1999     $result['target_contact_id'] = $params['target_contact_id'];
2000     $result['assignee_contact_id'] = $params['assignee_contact_id'];
2001     return $result;
2002   }
2003
2004   /**
2005    * Create an activity type.
2006    *
2007    * @param array $params
2008    *   Parameters.
2009    * @return array
2010    */
2011   public function activityTypeCreate($params) {
2012     return $this->callAPISuccess('ActivityType', 'create', $params);
2013   }
2014
2015   /**
2016    * Delete activity type.
2017    *
2018    * @param int $activityTypeId
2019    *   Id of the activity type.
2020    * @return array
2021    */
2022   public function activityTypeDelete($activityTypeId) {
2023     $params['activity_type_id'] = $activityTypeId;
2024     return $this->callAPISuccess('ActivityType', 'delete', $params);
2025   }
2026
2027   /**
2028    * Create custom group.
2029    *
2030    * @param array $params
2031    * @return array
2032    */
2033   public function customGroupCreate($params = array()) {
2034     $defaults = array(
2035       'title' => 'new custom group',
2036       'extends' => 'Contact',
2037       'domain_id' => 1,
2038       'style' => 'Inline',
2039       'is_active' => 1,
2040     );
2041
2042     $params = array_merge($defaults, $params);
2043
2044     if (strlen($params['title']) > 13) {
2045       $params['title'] = substr($params['title'], 0, 13);
2046     }
2047
2048     //have a crack @ deleting it first in the hope this will prevent derailing our tests
2049     $this->callAPISuccess('custom_group', 'get', array(
2050       'title' => $params['title'],
2051       array('api.custom_group.delete' => 1),
2052     ));
2053
2054     return $this->callAPISuccess('custom_group', 'create', $params);
2055   }
2056
2057   /**
2058    * Existing function doesn't allow params to be over-ridden so need a new one
2059    * this one allows you to only pass in the params you want to change
2060    * @param array $params
2061    * @return array|int
2062    */
2063   public function CustomGroupCreateByParams($params = array()) {
2064     $defaults = array(
2065       'title' => "API Custom Group",
2066       'extends' => 'Contact',
2067       'domain_id' => 1,
2068       'style' => 'Inline',
2069       'is_active' => 1,
2070     );
2071     $params = array_merge($defaults, $params);
2072     return $this->callAPISuccess('custom_group', 'create', $params);
2073   }
2074
2075   /**
2076    * Create custom group with multi fields.
2077    * @param array $params
2078    * @return array|int
2079    */
2080   public function CustomGroupMultipleCreateByParams($params = array()) {
2081     $defaults = array(
2082       'style' => 'Tab',
2083       'is_multiple' => 1,
2084     );
2085     $params = array_merge($defaults, $params);
2086     return $this->CustomGroupCreateByParams($params);
2087   }
2088
2089   /**
2090    * Create custom group with multi fields.
2091    * @param array $params
2092    * @return array
2093    */
2094   public function CustomGroupMultipleCreateWithFields($params = array()) {
2095     // also need to pass on $params['custom_field'] if not set but not in place yet
2096     $ids = array();
2097     $customGroup = $this->CustomGroupMultipleCreateByParams($params);
2098     $ids['custom_group_id'] = $customGroup['id'];
2099
2100     $customField = $this->customFieldCreate(array(
2101       'custom_group_id' => $ids['custom_group_id'],
2102       'label' => 'field_1' . $ids['custom_group_id'],
2103       'in_selector' => 1,
2104     ));
2105
2106     $ids['custom_field_id'][] = $customField['id'];
2107
2108     $customField = $this->customFieldCreate(array(
2109       'custom_group_id' => $ids['custom_group_id'],
2110       'default_value' => '',
2111       'label' => 'field_2' . $ids['custom_group_id'],
2112       'in_selector' => 1,
2113     ));
2114     $ids['custom_field_id'][] = $customField['id'];
2115
2116     $customField = $this->customFieldCreate(array(
2117       'custom_group_id' => $ids['custom_group_id'],
2118       'default_value' => '',
2119       'label' => 'field_3' . $ids['custom_group_id'],
2120       'in_selector' => 1,
2121     ));
2122     $ids['custom_field_id'][] = $customField['id'];
2123
2124     return $ids;
2125   }
2126
2127   /**
2128    * Create a custom group with a single text custom field.  See
2129    * participant:testCreateWithCustom for how to use this
2130    *
2131    * @param string $function
2132    *   __FUNCTION__.
2133    * @param string $filename
2134    *   $file __FILE__.
2135    *
2136    * @return array
2137    *   ids of created objects
2138    */
2139   public function entityCustomGroupWithSingleFieldCreate($function, $filename) {
2140     $params = array('title' => $function);
2141     $entity = substr(basename($filename), 0, strlen(basename($filename)) - 8);
2142     $params['extends'] = $entity ? $entity : 'Contact';
2143     $customGroup = $this->CustomGroupCreate($params);
2144     $customField = $this->customFieldCreate(array('custom_group_id' => $customGroup['id'], 'label' => $function));
2145     CRM_Core_PseudoConstant::flush();
2146
2147     return array('custom_group_id' => $customGroup['id'], 'custom_field_id' => $customField['id']);
2148   }
2149
2150   /**
2151    * Delete custom group.
2152    *
2153    * @param int $customGroupID
2154    *
2155    * @return array|int
2156    */
2157   public function customGroupDelete($customGroupID) {
2158     $params['id'] = $customGroupID;
2159     return $this->callAPISuccess('custom_group', 'delete', $params);
2160   }
2161
2162   /**
2163    * Create custom field.
2164    *
2165    * @param array $params
2166    *   (custom_group_id) is required.
2167    * @return array
2168    */
2169   public function customFieldCreate($params) {
2170     $params = array_merge(array(
2171       'label' => 'Custom Field',
2172       'data_type' => 'String',
2173       'html_type' => 'Text',
2174       'is_searchable' => 1,
2175       'is_active' => 1,
2176       'default_value' => 'defaultValue',
2177     ), $params);
2178
2179     $result = $this->callAPISuccess('custom_field', 'create', $params);
2180     // these 2 functions are called with force to flush static caches
2181     CRM_Core_BAO_CustomField::getTableColumnGroup($result['id'], 1);
2182     CRM_Core_Component::getEnabledComponents(1);
2183     return $result;
2184   }
2185
2186   /**
2187    * Delete custom field.
2188    *
2189    * @param int $customFieldID
2190    *
2191    * @return array|int
2192    */
2193   public function customFieldDelete($customFieldID) {
2194
2195     $params['id'] = $customFieldID;
2196     return $this->callAPISuccess('custom_field', 'delete', $params);
2197   }
2198
2199   /**
2200    * Create note.
2201    *
2202    * @param int $cId
2203    * @return array
2204    */
2205   public function noteCreate($cId) {
2206     $params = array(
2207       'entity_table' => 'civicrm_contact',
2208       'entity_id' => $cId,
2209       'note' => 'hello I am testing Note',
2210       'contact_id' => $cId,
2211       'modified_date' => date('Ymd'),
2212       'subject' => 'Test Note',
2213     );
2214
2215     return $this->callAPISuccess('Note', 'create', $params);
2216   }
2217
2218   /**
2219    * Enable CiviCampaign Component.
2220    */
2221   public function enableCiviCampaign() {
2222     CRM_Core_BAO_ConfigSetting::enableComponent('CiviCampaign');
2223     // force reload of config object
2224     $config = CRM_Core_Config::singleton(TRUE, TRUE);
2225     //flush cache by calling with reset
2226     $activityTypes = CRM_Core_PseudoConstant::activityType(TRUE, TRUE, TRUE, 'name', TRUE);
2227   }
2228
2229   /**
2230    * Create test generated example in api/v3/examples.
2231    *
2232    * To turn this off (e.g. on the server) set
2233    * define(DONT_DOCUMENT_TEST_CONFIG ,1);
2234    * in your settings file
2235    *
2236    * @param string $entity
2237    * @param string $action
2238    * @param array $params
2239    *   Array as passed to civicrm_api function.
2240    * @param array $result
2241    *   Array as received from the civicrm_api function.
2242    * @param string $testFunction
2243    *   Calling function - generally __FUNCTION__.
2244    * @param string $testFile
2245    *   Called from file - generally __FILE__.
2246    * @param string $description
2247    *   Descriptive text for the example file.
2248    * @param string $exampleName
2249    *   Name for this example file (CamelCase) - if omitted the action name will be substituted.
2250    */
2251   private function documentMe($entity, $action, $params, $result, $testFunction, $testFile, $description = "", $exampleName = NULL) {
2252     if (defined('DONT_DOCUMENT_TEST_CONFIG') && DONT_DOCUMENT_TEST_CONFIG) {
2253       return;
2254     }
2255     $entity = _civicrm_api_get_camel_name($entity);
2256     $action = strtolower($action);
2257
2258     if (empty($exampleName)) {
2259       // Attempt to convert lowercase action name to CamelCase.
2260       // This is clunky/imperfect due to the convention of all lowercase actions.
2261       $exampleName = CRM_Utils_String::convertStringToCamel($action);
2262       $knownPrefixes = array(
2263         'Get',
2264         'Set',
2265         'Create',
2266         'Update',
2267         'Send',
2268       );
2269       foreach ($knownPrefixes as $prefix) {
2270         if (strpos($exampleName, $prefix) === 0 && $prefix != $exampleName) {
2271           $exampleName[strlen($prefix)] = strtoupper($exampleName[strlen($prefix)]);
2272         }
2273       }
2274     }
2275
2276     $this->tidyExampleResult($result);
2277     if (isset($params['version'])) {
2278       unset($params['version']);
2279     }
2280     // Format multiline description as array
2281     $desc = array();
2282     if (is_string($description) && strlen($description)) {
2283       foreach (explode("\n", $description) as $line) {
2284         $desc[] = trim($line);
2285       }
2286     }
2287     $smarty = CRM_Core_Smarty::singleton();
2288     $smarty->assign('testFunction', $testFunction);
2289     $smarty->assign('function', _civicrm_api_get_entity_name_from_camel($entity) . "_$action");
2290     $smarty->assign('params', $params);
2291     $smarty->assign('entity', $entity);
2292     $smarty->assign('testFile', basename($testFile));
2293     $smarty->assign('description', $desc);
2294     $smarty->assign('result', $result);
2295     $smarty->assign('action', $action);
2296
2297     global $civicrm_root;
2298     if (file_exists($civicrm_root . '/tests/templates/documentFunction.tpl')) {
2299       if (!is_dir($civicrm_root . "/api/v3/examples/$entity")) {
2300         mkdir($civicrm_root . "/api/v3/examples/$entity");
2301       }
2302       $f = fopen($civicrm_root . "/api/v3/examples/$entity/$exampleName.php", "w+b");
2303       fwrite($f, $smarty->fetch($civicrm_root . '/tests/templates/documentFunction.tpl'));
2304       fclose($f);
2305     }
2306   }
2307
2308   /**
2309    * Tidy up examples array so that fields that change often ..don't
2310    * and debug related fields are unset
2311    *
2312    * @param array $result
2313    */
2314   public function tidyExampleResult(&$result) {
2315     if (!is_array($result)) {
2316       return;
2317     }
2318     $fieldsToChange = array(
2319       'hash' => '67eac7789eaee00',
2320       'modified_date' => '2012-11-14 16:02:35',
2321       'created_date' => '2013-07-28 08:49:19',
2322       'create_date' => '20120130621222105',
2323       'application_received_date' => '20130728084957',
2324       'in_date' => '2013-07-28 08:50:19',
2325       'scheduled_date' => '20130728085413',
2326       'approval_date' => '20130728085413',
2327       'pledge_start_date_high' => '20130726090416',
2328       'start_date' => '2013-07-29 00:00:00',
2329       'event_start_date' => '2013-07-29 00:00:00',
2330       'end_date' => '2013-08-04 00:00:00',
2331       'event_end_date' => '2013-08-04 00:00:00',
2332       'decision_date' => '20130805000000',
2333     );
2334
2335     $keysToUnset = array('xdebug', 'undefined_fields');
2336     foreach ($keysToUnset as $unwantedKey) {
2337       if (isset($result[$unwantedKey])) {
2338         unset($result[$unwantedKey]);
2339       }
2340     }
2341     if (isset($result['values'])) {
2342       if (!is_array($result['values'])) {
2343         return;
2344       }
2345       $resultArray = &$result['values'];
2346     }
2347     elseif (is_array($result)) {
2348       $resultArray = &$result;
2349     }
2350     else {
2351       return;
2352     }
2353
2354     foreach ($resultArray as $index => &$values) {
2355       if (!is_array($values)) {
2356         continue;
2357       }
2358       foreach ($values as $key => &$value) {
2359         if (substr($key, 0, 3) == 'api' && is_array($value)) {
2360           if (isset($value['is_error'])) {
2361             // we have a std nested result format
2362             $this->tidyExampleResult($value);
2363           }
2364           else {
2365             foreach ($value as &$nestedResult) {
2366               // this is an alternative syntax for nested results a keyed array of results
2367               $this->tidyExampleResult($nestedResult);
2368             }
2369           }
2370         }
2371         if (in_array($key, $keysToUnset)) {
2372           unset($values[$key]);
2373           break;
2374         }
2375         if (array_key_exists($key, $fieldsToChange) && !empty($value)) {
2376           $value = $fieldsToChange[$key];
2377         }
2378         if (is_string($value)) {
2379           $value = addslashes($value);
2380         }
2381       }
2382     }
2383   }
2384
2385   /**
2386    * Delete note.
2387    *
2388    * @param array $params
2389    *
2390    * @return array|int
2391    */
2392   public function noteDelete($params) {
2393     return $this->callAPISuccess('Note', 'delete', $params);
2394   }
2395
2396   /**
2397    * Create custom field with Option Values.
2398    *
2399    * @param array $customGroup
2400    * @param string $name
2401    *   Name of custom field.
2402    *
2403    * @return array|int
2404    */
2405   public function customFieldOptionValueCreate($customGroup, $name) {
2406     $fieldParams = array(
2407       'custom_group_id' => $customGroup['id'],
2408       'name' => 'test_custom_group',
2409       'label' => 'Country',
2410       'html_type' => 'Select',
2411       'data_type' => 'String',
2412       'weight' => 4,
2413       'is_required' => 1,
2414       'is_searchable' => 0,
2415       'is_active' => 1,
2416     );
2417
2418     $optionGroup = array(
2419       'domain_id' => 1,
2420       'name' => 'option_group1',
2421       'label' => 'option_group_label1',
2422     );
2423
2424     $optionValue = array(
2425       'option_label' => array('Label1', 'Label2'),
2426       'option_value' => array('value1', 'value2'),
2427       'option_name' => array($name . '_1', $name . '_2'),
2428       'option_weight' => array(1, 2),
2429       'option_status' => 1,
2430     );
2431
2432     $params = array_merge($fieldParams, $optionGroup, $optionValue);
2433
2434     return $this->callAPISuccess('custom_field', 'create', $params);
2435   }
2436
2437   /**
2438    * @param $entities
2439    *
2440    * @return bool
2441    */
2442   public function confirmEntitiesDeleted($entities) {
2443     foreach ($entities as $entity) {
2444
2445       $result = $this->callAPISuccess($entity, 'Get', array());
2446       if ($result['error'] == 1 || $result['count'] > 0) {
2447         // > than $entity[0] to allow a value to be passed in? e.g. domain?
2448         return TRUE;
2449       }
2450     }
2451     return FALSE;
2452   }
2453
2454   /**
2455    * Quick clean by emptying tables created for the test.
2456    *
2457    * @param array $tablesToTruncate
2458    * @param bool $dropCustomValueTables
2459    * @throws \Exception
2460    */
2461   public function quickCleanup($tablesToTruncate, $dropCustomValueTables = FALSE) {
2462     if ($this->tx) {
2463       throw new Exception("CiviUnitTestCase: quickCleanup() is not compatible with useTransaction()");
2464     }
2465     if ($dropCustomValueTables) {
2466       $optionGroupResult = CRM_Core_DAO::executeQuery('SELECT option_group_id FROM civicrm_custom_field');
2467       while ($optionGroupResult->fetch()) {
2468         if (!empty($optionGroupResult->option_group_id)) {
2469           CRM_Core_DAO::executeQuery('DELETE FROM civicrm_option_group WHERE id = ' . $optionGroupResult->option_group_id);
2470         }
2471       }
2472       $tablesToTruncate[] = 'civicrm_custom_group';
2473       $tablesToTruncate[] = 'civicrm_custom_field';
2474     }
2475
2476     $tablesToTruncate = array_unique(array_merge($this->_tablesToTruncate, $tablesToTruncate));
2477
2478     CRM_Core_DAO::executeQuery("SET FOREIGN_KEY_CHECKS = 0;");
2479     foreach ($tablesToTruncate as $table) {
2480       $sql = "TRUNCATE TABLE $table";
2481       CRM_Core_DAO::executeQuery($sql);
2482     }
2483     CRM_Core_DAO::executeQuery("SET FOREIGN_KEY_CHECKS = 1;");
2484
2485     if ($dropCustomValueTables) {
2486       $dbName = self::getDBName();
2487       $query = "
2488 SELECT TABLE_NAME as tableName
2489 FROM   INFORMATION_SCHEMA.TABLES
2490 WHERE  TABLE_SCHEMA = '{$dbName}'
2491 AND    ( TABLE_NAME LIKE 'civicrm_value_%' )
2492 ";
2493
2494       $tableDAO = CRM_Core_DAO::executeQuery($query);
2495       while ($tableDAO->fetch()) {
2496         $sql = "DROP TABLE {$tableDAO->tableName}";
2497         CRM_Core_DAO::executeQuery($sql);
2498       }
2499     }
2500   }
2501
2502   /**
2503    * Clean up financial entities after financial tests (so we remember to get all the tables :-))
2504    */
2505   public function quickCleanUpFinancialEntities() {
2506     $tablesToTruncate = array(
2507       'civicrm_activity',
2508       'civicrm_activity_contact',
2509       'civicrm_contribution',
2510       'civicrm_contribution_soft',
2511       'civicrm_contribution_product',
2512       'civicrm_financial_trxn',
2513       'civicrm_financial_item',
2514       'civicrm_contribution_recur',
2515       'civicrm_line_item',
2516       'civicrm_contribution_page',
2517       'civicrm_payment_processor',
2518       'civicrm_entity_financial_trxn',
2519       'civicrm_membership',
2520       'civicrm_membership_type',
2521       'civicrm_membership_payment',
2522       'civicrm_membership_log',
2523       'civicrm_membership_block',
2524       'civicrm_event',
2525       'civicrm_participant',
2526       'civicrm_participant_payment',
2527       'civicrm_pledge',
2528       'civicrm_pledge_payment',
2529       'civicrm_price_set_entity',
2530       'civicrm_price_field_value',
2531       'civicrm_price_field',
2532     );
2533     $this->quickCleanup($tablesToTruncate);
2534     CRM_Core_DAO::executeQuery("DELETE FROM civicrm_membership_status WHERE name NOT IN('New', 'Current', 'Grace', 'Expired', 'Pending', 'Cancelled', 'Deceased')");
2535     $this->restoreDefaultPriceSetConfig();
2536     $var = TRUE;
2537     CRM_Member_BAO_Membership::createRelatedMemberships($var, $var, TRUE);
2538     System::singleton()->flushProcessors();
2539   }
2540
2541   public function restoreDefaultPriceSetConfig() {
2542     CRM_Core_DAO::executeQuery('DELETE FROM civicrm_price_set WHERE id > 2');
2543     CRM_Core_DAO::executeQuery("INSERT INTO `civicrm_price_field` (`id`, `price_set_id`, `name`, `label`, `html_type`, `is_enter_qty`, `help_pre`, `help_post`, `weight`, `is_display_amounts`, `options_per_line`, `is_active`, `is_required`, `active_on`, `expire_on`, `javascript`, `visibility_id`) VALUES (1, 1, 'contribution_amount', 'Contribution Amount', 'Text', 0, NULL, NULL, 1, 1, 1, 1, 1, NULL, NULL, NULL, 1)");
2544     CRM_Core_DAO::executeQuery("INSERT INTO `civicrm_price_field_value` (`id`, `price_field_id`, `name`, `label`, `description`, `amount`, `count`, `max_value`, `weight`, `membership_type_id`, `membership_num_terms`, `is_default`, `is_active`, `financial_type_id`, `deductible_amount`) VALUES (1, 1, 'contribution_amount', 'Contribution Amount', NULL, '1', NULL, NULL, 1, NULL, NULL, 0, 1, 1, 0.00)");
2545   }
2546   /*
2547    * Function does a 'Get' on the entity & compares the fields in the Params with those returned
2548    * Default behaviour is to also delete the entity
2549    * @param array $params
2550    *   Params array to check against.
2551    * @param int $id
2552    *   Id of the entity concerned.
2553    * @param string $entity
2554    *   Name of entity concerned (e.g. membership).
2555    * @param bool $delete
2556    *   Should the entity be deleted as part of this check.
2557    * @param string $errorText
2558    *   Text to print on error.
2559    */
2560   /**
2561    * @param array $params
2562    * @param int $id
2563    * @param $entity
2564    * @param int $delete
2565    * @param string $errorText
2566    *
2567    * @throws Exception
2568    */
2569   public function getAndCheck($params, $id, $entity, $delete = 1, $errorText = '') {
2570
2571     $result = $this->callAPISuccessGetSingle($entity, array(
2572       'id' => $id,
2573     ));
2574
2575     if ($delete) {
2576       $this->callAPISuccess($entity, 'Delete', array(
2577         'id' => $id,
2578       ));
2579     }
2580     $dateFields = $keys = $dateTimeFields = array();
2581     $fields = $this->callAPISuccess($entity, 'getfields', array('version' => 3, 'action' => 'get'));
2582     foreach ($fields['values'] as $field => $settings) {
2583       if (array_key_exists($field, $result)) {
2584         $keys[CRM_Utils_Array::Value('name', $settings, $field)] = $field;
2585       }
2586       else {
2587         $keys[CRM_Utils_Array::Value('name', $settings, $field)] = CRM_Utils_Array::value('name', $settings, $field);
2588       }
2589       $type = CRM_Utils_Array::value('type', $settings);
2590       if ($type == CRM_Utils_Type::T_DATE) {
2591         $dateFields[] = $settings['name'];
2592         // we should identify both real names & unique names as dates
2593         if ($field != $settings['name']) {
2594           $dateFields[] = $field;
2595         }
2596       }
2597       if ($type == CRM_Utils_Type::T_DATE + CRM_Utils_Type::T_TIME) {
2598         $dateTimeFields[] = $settings['name'];
2599         // we should identify both real names & unique names as dates
2600         if ($field != $settings['name']) {
2601           $dateTimeFields[] = $field;
2602         }
2603       }
2604     }
2605
2606     if (strtolower($entity) == 'contribution') {
2607       $params['receive_date'] = date('Y-m-d', strtotime($params['receive_date']));
2608       // this is not returned in id format
2609       unset($params['payment_instrument_id']);
2610       $params['contribution_source'] = $params['source'];
2611       unset($params['source']);
2612     }
2613
2614     foreach ($params as $key => $value) {
2615       if ($key == 'version' || substr($key, 0, 3) == 'api' || !array_key_exists($keys[$key], $result)) {
2616         continue;
2617       }
2618       if (in_array($key, $dateFields)) {
2619         $value = date('Y-m-d', strtotime($value));
2620         $result[$key] = date('Y-m-d', strtotime($result[$key]));
2621       }
2622       if (in_array($key, $dateTimeFields)) {
2623         $value = date('Y-m-d H:i:s', strtotime($value));
2624         $result[$keys[$key]] = date('Y-m-d H:i:s', strtotime(CRM_Utils_Array::value($keys[$key], $result, CRM_Utils_Array::value($key, $result))));
2625       }
2626       $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);
2627     }
2628   }
2629
2630   /**
2631    * Get formatted values in  the actual and expected result.
2632    * @param array $actual
2633    *   Actual calculated values.
2634    * @param array $expected
2635    *   Expected values.
2636    */
2637   public function checkArrayEquals(&$actual, &$expected) {
2638     self::unsetId($actual);
2639     self::unsetId($expected);
2640     $this->assertEquals($actual, $expected);
2641   }
2642
2643   /**
2644    * Unset the key 'id' from the array
2645    * @param array $unformattedArray
2646    *   The array from which the 'id' has to be unset.
2647    */
2648   public static function unsetId(&$unformattedArray) {
2649     $formattedArray = array();
2650     if (array_key_exists('id', $unformattedArray)) {
2651       unset($unformattedArray['id']);
2652     }
2653     if (!empty($unformattedArray['values']) && is_array($unformattedArray['values'])) {
2654       foreach ($unformattedArray['values'] as $key => $value) {
2655         if (is_array($value)) {
2656           foreach ($value as $k => $v) {
2657             if ($k == 'id') {
2658               unset($value[$k]);
2659             }
2660           }
2661         }
2662         elseif ($key == 'id') {
2663           $unformattedArray[$key];
2664         }
2665         $formattedArray = array($value);
2666       }
2667       $unformattedArray['values'] = $formattedArray;
2668     }
2669   }
2670
2671   /**
2672    *  Helper to enable/disable custom directory support
2673    *
2674    * @param array $customDirs
2675    *   With members:.
2676    *   'php_path' Set to TRUE to use the default, FALSE or "" to disable support, or a string path to use another path
2677    *   'template_path' Set to TRUE to use the default, FALSE or "" to disable support, or a string path to use another path
2678    */
2679   public function customDirectories($customDirs) {
2680     $config = CRM_Core_Config::singleton();
2681
2682     if (empty($customDirs['php_path']) || $customDirs['php_path'] === FALSE) {
2683       unset($config->customPHPPathDir);
2684     }
2685     elseif ($customDirs['php_path'] === TRUE) {
2686       $config->customPHPPathDir = dirname(dirname(__FILE__)) . '/custom_directories/php/';
2687     }
2688     else {
2689       $config->customPHPPathDir = $php_path;
2690     }
2691
2692     if (empty($customDirs['template_path']) || $customDirs['template_path'] === FALSE) {
2693       unset($config->customTemplateDir);
2694     }
2695     elseif ($customDirs['template_path'] === TRUE) {
2696       $config->customTemplateDir = dirname(dirname(__FILE__)) . '/custom_directories/templates/';
2697     }
2698     else {
2699       $config->customTemplateDir = $template_path;
2700     }
2701   }
2702
2703   /**
2704    * Generate a temporary folder.
2705    *
2706    * @param string $prefix
2707    * @return string
2708    */
2709   public function createTempDir($prefix = 'test-') {
2710     $tempDir = CRM_Utils_File::tempdir($prefix);
2711     $this->tempDirs[] = $tempDir;
2712     return $tempDir;
2713   }
2714
2715   public function cleanTempDirs() {
2716     if (!is_array($this->tempDirs)) {
2717       // fix test errors where this is not set
2718       return;
2719     }
2720     foreach ($this->tempDirs as $tempDir) {
2721       if (is_dir($tempDir)) {
2722         CRM_Utils_File::cleanDir($tempDir, TRUE, FALSE);
2723       }
2724     }
2725   }
2726
2727   /**
2728    * Temporarily replace the singleton extension with a different one.
2729    * @param \CRM_Extension_System $system
2730    */
2731   public function setExtensionSystem(CRM_Extension_System $system) {
2732     if ($this->origExtensionSystem == NULL) {
2733       $this->origExtensionSystem = CRM_Extension_System::singleton();
2734     }
2735     CRM_Extension_System::setSingleton($this->origExtensionSystem);
2736   }
2737
2738   public function unsetExtensionSystem() {
2739     if ($this->origExtensionSystem !== NULL) {
2740       CRM_Extension_System::setSingleton($this->origExtensionSystem);
2741       $this->origExtensionSystem = NULL;
2742     }
2743   }
2744
2745   /**
2746    * Temporarily alter the settings-metadata to add a mock setting.
2747    *
2748    * WARNING: The setting metadata will disappear on the next cache-clear.
2749    *
2750    * @param $extras
2751    * @return void
2752    */
2753   public function setMockSettingsMetaData($extras) {
2754     Civi::service('settings_manager')->flush();
2755
2756     CRM_Utils_Hook::singleton()
2757       ->setHook('civicrm_alterSettingsMetaData', function (&$metadata, $domainId, $profile) use ($extras) {
2758         $metadata = array_merge($metadata, $extras);
2759       });
2760
2761     $fields = $this->callAPISuccess('setting', 'getfields', array());
2762     foreach ($extras as $key => $spec) {
2763       $this->assertNotEmpty($spec['title']);
2764       $this->assertEquals($spec['title'], $fields['values'][$key]['title']);
2765     }
2766   }
2767
2768   /**
2769    * @param string $name
2770    */
2771   public function financialAccountDelete($name) {
2772     $financialAccount = new CRM_Financial_DAO_FinancialAccount();
2773     $financialAccount->name = $name;
2774     if ($financialAccount->find(TRUE)) {
2775       $entityFinancialType = new CRM_Financial_DAO_EntityFinancialAccount();
2776       $entityFinancialType->financial_account_id = $financialAccount->id;
2777       $entityFinancialType->delete();
2778       $financialAccount->delete();
2779     }
2780   }
2781
2782   /**
2783    * FIXME: something NULLs $GLOBALS['_HTML_QuickForm_registered_rules'] when the tests are ran all together
2784    * (NB unclear if this is still required)
2785    */
2786   public function _sethtmlGlobals() {
2787     $GLOBALS['_HTML_QuickForm_registered_rules'] = array(
2788       'required' => array(
2789         'html_quickform_rule_required',
2790         'HTML/QuickForm/Rule/Required.php',
2791       ),
2792       'maxlength' => array(
2793         'html_quickform_rule_range',
2794         'HTML/QuickForm/Rule/Range.php',
2795       ),
2796       'minlength' => array(
2797         'html_quickform_rule_range',
2798         'HTML/QuickForm/Rule/Range.php',
2799       ),
2800       'rangelength' => array(
2801         'html_quickform_rule_range',
2802         'HTML/QuickForm/Rule/Range.php',
2803       ),
2804       'email' => array(
2805         'html_quickform_rule_email',
2806         'HTML/QuickForm/Rule/Email.php',
2807       ),
2808       'regex' => array(
2809         'html_quickform_rule_regex',
2810         'HTML/QuickForm/Rule/Regex.php',
2811       ),
2812       'lettersonly' => array(
2813         'html_quickform_rule_regex',
2814         'HTML/QuickForm/Rule/Regex.php',
2815       ),
2816       'alphanumeric' => array(
2817         'html_quickform_rule_regex',
2818         'HTML/QuickForm/Rule/Regex.php',
2819       ),
2820       'numeric' => array(
2821         'html_quickform_rule_regex',
2822         'HTML/QuickForm/Rule/Regex.php',
2823       ),
2824       'nopunctuation' => array(
2825         'html_quickform_rule_regex',
2826         'HTML/QuickForm/Rule/Regex.php',
2827       ),
2828       'nonzero' => array(
2829         'html_quickform_rule_regex',
2830         'HTML/QuickForm/Rule/Regex.php',
2831       ),
2832       'callback' => array(
2833         'html_quickform_rule_callback',
2834         'HTML/QuickForm/Rule/Callback.php',
2835       ),
2836       'compare' => array(
2837         'html_quickform_rule_compare',
2838         'HTML/QuickForm/Rule/Compare.php',
2839       ),
2840     );
2841     // FIXME: …ditto for $GLOBALS['HTML_QUICKFORM_ELEMENT_TYPES']
2842     $GLOBALS['HTML_QUICKFORM_ELEMENT_TYPES'] = array(
2843       'group' => array(
2844         'HTML/QuickForm/group.php',
2845         'HTML_QuickForm_group',
2846       ),
2847       'hidden' => array(
2848         'HTML/QuickForm/hidden.php',
2849         'HTML_QuickForm_hidden',
2850       ),
2851       'reset' => array(
2852         'HTML/QuickForm/reset.php',
2853         'HTML_QuickForm_reset',
2854       ),
2855       'checkbox' => array(
2856         'HTML/QuickForm/checkbox.php',
2857         'HTML_QuickForm_checkbox',
2858       ),
2859       'file' => array(
2860         'HTML/QuickForm/file.php',
2861         'HTML_QuickForm_file',
2862       ),
2863       'image' => array(
2864         'HTML/QuickForm/image.php',
2865         'HTML_QuickForm_image',
2866       ),
2867       'password' => array(
2868         'HTML/QuickForm/password.php',
2869         'HTML_QuickForm_password',
2870       ),
2871       'radio' => array(
2872         'HTML/QuickForm/radio.php',
2873         'HTML_QuickForm_radio',
2874       ),
2875       'button' => array(
2876         'HTML/QuickForm/button.php',
2877         'HTML_QuickForm_button',
2878       ),
2879       'submit' => array(
2880         'HTML/QuickForm/submit.php',
2881         'HTML_QuickForm_submit',
2882       ),
2883       'select' => array(
2884         'HTML/QuickForm/select.php',
2885         'HTML_QuickForm_select',
2886       ),
2887       'hiddenselect' => array(
2888         'HTML/QuickForm/hiddenselect.php',
2889         'HTML_QuickForm_hiddenselect',
2890       ),
2891       'text' => array(
2892         'HTML/QuickForm/text.php',
2893         'HTML_QuickForm_text',
2894       ),
2895       'textarea' => array(
2896         'HTML/QuickForm/textarea.php',
2897         'HTML_QuickForm_textarea',
2898       ),
2899       'fckeditor' => array(
2900         'HTML/QuickForm/fckeditor.php',
2901         'HTML_QuickForm_FCKEditor',
2902       ),
2903       'tinymce' => array(
2904         'HTML/QuickForm/tinymce.php',
2905         'HTML_QuickForm_TinyMCE',
2906       ),
2907       'dojoeditor' => array(
2908         'HTML/QuickForm/dojoeditor.php',
2909         'HTML_QuickForm_dojoeditor',
2910       ),
2911       'link' => array(
2912         'HTML/QuickForm/link.php',
2913         'HTML_QuickForm_link',
2914       ),
2915       'advcheckbox' => array(
2916         'HTML/QuickForm/advcheckbox.php',
2917         'HTML_QuickForm_advcheckbox',
2918       ),
2919       'date' => array(
2920         'HTML/QuickForm/date.php',
2921         'HTML_QuickForm_date',
2922       ),
2923       'static' => array(
2924         'HTML/QuickForm/static.php',
2925         'HTML_QuickForm_static',
2926       ),
2927       'header' => array(
2928         'HTML/QuickForm/header.php',
2929         'HTML_QuickForm_header',
2930       ),
2931       'html' => array(
2932         'HTML/QuickForm/html.php',
2933         'HTML_QuickForm_html',
2934       ),
2935       'hierselect' => array(
2936         'HTML/QuickForm/hierselect.php',
2937         'HTML_QuickForm_hierselect',
2938       ),
2939       'autocomplete' => array(
2940         'HTML/QuickForm/autocomplete.php',
2941         'HTML_QuickForm_autocomplete',
2942       ),
2943       'xbutton' => array(
2944         'HTML/QuickForm/xbutton.php',
2945         'HTML_QuickForm_xbutton',
2946       ),
2947       'advmultiselect' => array(
2948         'HTML/QuickForm/advmultiselect.php',
2949         'HTML_QuickForm_advmultiselect',
2950       ),
2951     );
2952   }
2953
2954   /**
2955    * Set up an acl allowing contact to see 2 specified groups
2956    *  - $this->_permissionedGroup & $this->_permissionedDisabledGroup
2957    *
2958    *  You need to have pre-created these groups & created the user e.g
2959    *  $this->createLoggedInUser();
2960    *   $this->_permissionedDisabledGroup = $this->groupCreate(array('title' => 'pick-me-disabled', 'is_active' => 0, 'name' => 'pick-me-disabled'));
2961    *   $this->_permissionedGroup = $this->groupCreate(array('title' => 'pick-me-active', 'is_active' => 1, 'name' => 'pick-me-active'));
2962    *
2963    * @param bool $isProfile
2964    */
2965   public function setupACL($isProfile = FALSE) {
2966     global $_REQUEST;
2967     $_REQUEST = $this->_params;
2968
2969     CRM_Core_Config::singleton()->userPermissionClass->permissions = array('access CiviCRM');
2970     $optionGroupID = $this->callAPISuccessGetValue('option_group', array('return' => 'id', 'name' => 'acl_role'));
2971     $optionValue = $this->callAPISuccess('option_value', 'create', array(
2972       'option_group_id' => $optionGroupID,
2973       'label' => 'pick me',
2974       'value' => 55,
2975     ));
2976
2977     CRM_Core_DAO::executeQuery("
2978       TRUNCATE civicrm_acl_cache
2979     ");
2980
2981     CRM_Core_DAO::executeQuery("
2982       TRUNCATE civicrm_acl_contact_cache
2983     ");
2984
2985     CRM_Core_DAO::executeQuery("
2986     INSERT INTO civicrm_acl_entity_role (
2987     `acl_role_id`, `entity_table`, `entity_id`, `is_active`
2988     ) VALUES (55, 'civicrm_group', {$this->_permissionedGroup}, 1);
2989     ");
2990
2991     if ($isProfile) {
2992       CRM_Core_DAO::executeQuery("
2993       INSERT INTO civicrm_acl (
2994       `name`, `entity_table`, `entity_id`, `operation`, `object_table`, `object_id`, `is_active`
2995       )
2996       VALUES (
2997       'view picked', 'civicrm_acl_role', 55, 'Edit', 'civicrm_uf_group', 0, 1
2998       );
2999       ");
3000     }
3001     else {
3002       CRM_Core_DAO::executeQuery("
3003       INSERT INTO civicrm_acl (
3004       `name`, `entity_table`, `entity_id`, `operation`, `object_table`, `object_id`, `is_active`
3005       )
3006       VALUES (
3007       'view picked', 'civicrm_group', $this->_permissionedGroup , 'Edit', 'civicrm_saved_search', {$this->_permissionedGroup}, 1
3008       );
3009       ");
3010
3011       CRM_Core_DAO::executeQuery("
3012       INSERT INTO civicrm_acl (
3013       `name`, `entity_table`, `entity_id`, `operation`, `object_table`, `object_id`, `is_active`
3014       )
3015       VALUES (
3016       'view picked', 'civicrm_group',  $this->_permissionedGroup, 'Edit', 'civicrm_saved_search', {$this->_permissionedDisabledGroup}, 1
3017       );
3018       ");
3019     }
3020
3021     $this->_loggedInUser = CRM_Core_Session::singleton()->get('userID');
3022     $this->callAPISuccess('group_contact', 'create', array(
3023       'group_id' => $this->_permissionedGroup,
3024       'contact_id' => $this->_loggedInUser,
3025     ));
3026
3027     if (!$isProfile) {
3028       //flush cache
3029       CRM_ACL_BAO_Cache::resetCache();
3030       CRM_Contact_BAO_Group::getPermissionClause(TRUE);
3031       CRM_ACL_API::groupPermission('whatever', 9999, NULL, 'civicrm_saved_search', NULL, NULL, TRUE);
3032     }
3033   }
3034
3035   /**
3036    * Alter default price set so that the field numbers are not all 1 (hiding errors)
3037    */
3038   public function offsetDefaultPriceSet() {
3039     $contributionPriceSet = $this->callAPISuccess('price_set', 'getsingle', array('name' => 'default_contribution_amount'));
3040     $firstID = $contributionPriceSet['id'];
3041     $this->callAPISuccess('price_set', 'create', array(
3042       'id' => $contributionPriceSet['id'],
3043       'is_active' => 0,
3044       'name' => 'old',
3045     ));
3046     unset($contributionPriceSet['id']);
3047     $newPriceSet = $this->callAPISuccess('price_set', 'create', $contributionPriceSet);
3048     $priceField = $this->callAPISuccess('price_field', 'getsingle', array(
3049       'price_set_id' => $firstID,
3050       'options' => array('limit' => 1),
3051     ));
3052     unset($priceField['id']);
3053     $priceField['price_set_id'] = $newPriceSet['id'];
3054     $newPriceField = $this->callAPISuccess('price_field', 'create', $priceField);
3055     $priceFieldValue = $this->callAPISuccess('price_field_value', 'getsingle', array(
3056       'price_set_id' => $firstID,
3057       'sequential' => 1,
3058       'options' => array('limit' => 1),
3059     ));
3060
3061     unset($priceFieldValue['id']);
3062     //create some padding to use up ids
3063     $this->callAPISuccess('price_field_value', 'create', $priceFieldValue);
3064     $this->callAPISuccess('price_field_value', 'create', $priceFieldValue);
3065     $this->callAPISuccess('price_field_value', 'create', array_merge($priceFieldValue, array('price_field_id' => $newPriceField['id'])));
3066   }
3067
3068   /**
3069    * Create an instance of the paypal processor.
3070    * @todo this isn't a great place to put it - but really it belongs on a class that extends
3071    * this parent class & we don't have a structure for that yet
3072    * There is another function to this effect on the PaypalPro test but it appears to be silently failing
3073    * & the best protection against that is the functions this class affords
3074    * @param array $params
3075    * @return int $result['id'] payment processor id
3076    */
3077   public function paymentProcessorCreate($params = array()) {
3078     $params = array_merge(array(
3079         'name' => 'demo',
3080         'domain_id' => CRM_Core_Config::domainID(),
3081         'payment_processor_type_id' => 'PayPal',
3082         'is_active' => 1,
3083         'is_default' => 0,
3084         'is_test' => 1,
3085         'user_name' => 'sunil._1183377782_biz_api1.webaccess.co.in',
3086         'password' => '1183377788',
3087         'signature' => 'APixCoQ-Zsaj-u3IH7mD5Do-7HUqA9loGnLSzsZga9Zr-aNmaJa3WGPH',
3088         'url_site' => 'https://www.sandbox.paypal.com/',
3089         'url_api' => 'https://api-3t.sandbox.paypal.com/',
3090         'url_button' => 'https://www.paypal.com/en_US/i/btn/btn_xpressCheckout.gif',
3091         'class_name' => 'Payment_PayPalImpl',
3092         'billing_mode' => 3,
3093         'financial_type_id' => 1,
3094         'financial_account_id' => 12,
3095       ),
3096       $params);
3097     if (!is_numeric($params['payment_processor_type_id'])) {
3098       // really the api should handle this through getoptions but it's not exactly api call so lets just sort it
3099       //here
3100       $params['payment_processor_type_id'] = $this->callAPISuccess('payment_processor_type', 'getvalue', array(
3101         'name' => $params['payment_processor_type_id'],
3102         'return' => 'id',
3103       ), 'integer');
3104     }
3105     $result = $this->callAPISuccess('payment_processor', 'create', $params);
3106     return $result['id'];
3107   }
3108
3109   /**
3110    * Set up initial recurring payment allowing subsequent IPN payments.
3111    */
3112   public function setupRecurringPaymentProcessorTransaction($params = array()) {
3113     $contributionRecur = $this->callAPISuccess('contribution_recur', 'create', array_merge(array(
3114       'contact_id' => $this->_contactID,
3115       'amount' => 1000,
3116       'sequential' => 1,
3117       'installments' => 5,
3118       'frequency_unit' => 'Month',
3119       'frequency_interval' => 1,
3120       'invoice_id' => $this->_invoiceID,
3121       'contribution_status_id' => 2,
3122       'payment_processor_id' => $this->_paymentProcessorID,
3123       // processor provided ID - use contact ID as proxy.
3124       'processor_id' => $this->_contactID,
3125       'api.contribution.create' => array(
3126         'total_amount' => '200',
3127         'invoice_id' => $this->_invoiceID,
3128         'financial_type_id' => 1,
3129         'contribution_status_id' => 'Pending',
3130         'contact_id' => $this->_contactID,
3131         'contribution_page_id' => $this->_contributionPageID,
3132         'payment_processor_id' => $this->_paymentProcessorID,
3133         'is_test' => 0,
3134       ),
3135     ), $params));
3136     $this->_contributionRecurID = $contributionRecur['id'];
3137     $this->_contributionID = $contributionRecur['values']['0']['api.contribution.create']['id'];
3138   }
3139
3140   /**
3141    * We don't have a good way to set up a recurring contribution with a membership so let's just do one then alter it
3142    */
3143   public function setupMembershipRecurringPaymentProcessorTransaction() {
3144     $this->ids['membership_type'] = $this->membershipTypeCreate();
3145     //create a contribution so our membership & contribution don't both have id = 1
3146     if ($this->callAPISuccess('Contribution', 'getcount', array()) == 0) {
3147       $this->contributionCreate(array(
3148         'contact_id' => $this->_contactID,
3149         'is_test' => 1,
3150         'financial_type_id' => 1,
3151         'invoice_id' => 'abcd',
3152         'trxn_id' => 345,
3153       ));
3154     }
3155     $this->setupRecurringPaymentProcessorTransaction();
3156
3157     $this->ids['membership'] = $this->callAPISuccess('membership', 'create', array(
3158       'contact_id' => $this->_contactID,
3159       'membership_type_id' => $this->ids['membership_type'],
3160       'contribution_recur_id' => $this->_contributionRecurID,
3161       'format.only_id' => TRUE,
3162     ));
3163     //CRM-15055 creates line items we don't want so get rid of them so we can set up our own line items
3164     CRM_Core_DAO::executeQuery("TRUNCATE civicrm_line_item");
3165
3166     $this->callAPISuccess('line_item', 'create', array(
3167       'entity_table' => 'civicrm_membership',
3168       'entity_id' => $this->ids['membership'],
3169       'contribution_id' => $this->_contributionID,
3170       'label' => 'General',
3171       'qty' => 1,
3172       'unit_price' => 200,
3173       'line_total' => 200,
3174       'financial_type_id' => 1,
3175       'price_field_id' => $this->callAPISuccess('price_field', 'getvalue', array(
3176         'return' => 'id',
3177         'label' => 'Membership Amount',
3178         'options' => array('limit' => 1, 'sort' => 'id DESC'),
3179       )),
3180       'price_field_value_id' => $this->callAPISuccess('price_field_value', 'getvalue', array(
3181         'return' => 'id',
3182         'label' => 'General',
3183         'options' => array('limit' => 1, 'sort' => 'id DESC'),
3184       )),
3185     ));
3186     $this->callAPISuccess('membership_payment', 'create', array(
3187       'contribution_id' => $this->_contributionID,
3188       'membership_id' => $this->ids['membership'],
3189     ));
3190   }
3191
3192   /**
3193    * @param $message
3194    *
3195    * @throws Exception
3196    */
3197   public function CiviUnitTestCase_fatalErrorHandler($message) {
3198     throw new Exception("{$message['message']}: {$message['code']}");
3199   }
3200
3201   /**
3202    * Helper function to create new mailing.
3203    * @return mixed
3204    */
3205   public function createMailing() {
3206     $params = array(
3207       'subject' => 'maild' . rand(),
3208       'body_text' => 'bdkfhdskfhduew{domain.address}{action.optOutUrl}',
3209       'name' => 'mailing name' . rand(),
3210       'created_id' => 1,
3211     );
3212
3213     $result = $this->callAPISuccess('Mailing', 'create', $params);
3214     return $result['id'];
3215   }
3216
3217   /**
3218    * Helper function to delete mailing.
3219    * @param $id
3220    */
3221   public function deleteMailing($id) {
3222     $params = array(
3223       'id' => $id,
3224     );
3225
3226     $this->callAPISuccess('Mailing', 'delete', $params);
3227   }
3228
3229   /**
3230    * Wrap the entire test case in a transaction.
3231    *
3232    * Only subsequent DB statements will be wrapped in TX -- this cannot
3233    * retroactively wrap old DB statements. Therefore, it makes sense to
3234    * call this at the beginning of setUp().
3235    *
3236    * Note: Recall that TRUNCATE and ALTER will force-commit transactions, so
3237    * this option does not work with, e.g., custom-data.
3238    *
3239    * WISHLIST: Monitor SQL queries in unit-tests and generate an exception
3240    * if TRUNCATE or ALTER is called while using a transaction.
3241    *
3242    * @param bool $nest
3243    *   Whether to use nesting or reference-counting.
3244    */
3245   public function useTransaction($nest = TRUE) {
3246     if (!$this->tx) {
3247       $this->tx = new CRM_Core_Transaction($nest);
3248       $this->tx->rollback();
3249     }
3250   }
3251
3252   /**
3253    * Assert the attachment exists.
3254    *
3255    * @param bool $exists
3256    * @param array $apiResult
3257    */
3258   protected function assertAttachmentExistence($exists, $apiResult) {
3259     $fileId = $apiResult['id'];
3260     $this->assertTrue(is_numeric($fileId));
3261     $this->assertEquals($exists, file_exists($apiResult['values'][$fileId]['path']));
3262     $this->assertDBQuery($exists ? 1 : 0, 'SELECT count(*) FROM civicrm_file WHERE id = %1', array(
3263       1 => array($fileId, 'Int'),
3264     ));
3265     $this->assertDBQuery($exists ? 1 : 0, 'SELECT count(*) FROM civicrm_entity_file WHERE id = %1', array(
3266       1 => array($fileId, 'Int'),
3267     ));
3268   }
3269
3270   /**
3271    * Create a price set for an event.
3272    *
3273    * @param int $feeTotal
3274    *
3275    * @return int
3276    *   Price Set ID.
3277    */
3278   protected function eventPriceSetCreate($feeTotal) {
3279     // creating price set, price field
3280     $paramsSet['title'] = 'Price Set';
3281     $paramsSet['name'] = CRM_Utils_String::titleToVar('Price Set');
3282     $paramsSet['is_active'] = FALSE;
3283     $paramsSet['extends'] = 1;
3284
3285     $priceset = CRM_Price_BAO_PriceSet::create($paramsSet);
3286     $priceSetId = $priceset->id;
3287
3288     //Checking for priceset added in the table.
3289     $this->assertDBCompareValue('CRM_Price_BAO_PriceSet', $priceSetId, 'title',
3290       'id', $paramsSet['title'], 'Check DB for created priceset'
3291     );
3292     $paramsField = array(
3293       'label' => 'Price Field',
3294       'name' => CRM_Utils_String::titleToVar('Price Field'),
3295       'html_type' => 'Text',
3296       'price' => $feeTotal,
3297       'option_label' => array('1' => 'Price Field'),
3298       'option_value' => array('1' => $feeTotal),
3299       'option_name' => array('1' => $feeTotal),
3300       'option_weight' => array('1' => 1),
3301       'option_amount' => array('1' => 1),
3302       'is_display_amounts' => 1,
3303       'weight' => 1,
3304       'options_per_line' => 1,
3305       'is_active' => array('1' => 1),
3306       'price_set_id' => $priceset->id,
3307       'is_enter_qty' => 1,
3308       'financial_type_id' => $this->getFinancialTypeId('Event Fee'),
3309     );
3310     CRM_Price_BAO_PriceField::create($paramsField);
3311
3312     return $priceSetId;
3313   }
3314
3315   /**
3316    * Add a profile to a contribution page.
3317    *
3318    * @param string $name
3319    * @param int $contributionPageID
3320    */
3321   protected function addProfile($name, $contributionPageID) {
3322     $this->callAPISuccess('UFJoin', 'create', array(
3323       'uf_group_id' => $name,
3324       'module' => 'CiviContribute',
3325       'entity_table' => 'civicrm_contribution_page',
3326       'entity_id' => $contributionPageID,
3327       'weight' => 1,
3328     ));
3329   }
3330
3331   /**
3332    * Add participant with contribution
3333    *
3334    * @return array
3335    */
3336   protected function createParticipantWithContribution() {
3337     // creating price set, price field
3338     $this->_contactId = $this->individualCreate();
3339     $event = $this->eventCreate();
3340     $this->_eventId = $event['id'];
3341     $eventParams = array(
3342       'id' => $this->_eventId,
3343       'financial_type_id' => 4,
3344       'is_monetary' => 1,
3345     );
3346     $this->callAPISuccess('event', 'create', $eventParams);
3347     $priceFields = $this->createPriceSet('event', $this->_eventId);
3348     $participantParams = array(
3349       'financial_type_id' => 4,
3350       'event_id' => $this->_eventId,
3351       'role_id' => 1,
3352       'status_id' => 14,
3353       'fee_currency' => 'USD',
3354       'contact_id' => $this->_contactId,
3355     );
3356     $participant = $this->callAPISuccess('Participant', 'create', $participantParams);
3357     $contributionParams = array(
3358       'total_amount' => 150,
3359       'currency' => 'USD',
3360       'contact_id' => $this->_contactId,
3361       'financial_type_id' => 4,
3362       'contribution_status_id' => 1,
3363       'partial_payment_total' => 300.00,
3364       'partial_amount_pay' => 150,
3365       'contribution_mode' => 'participant',
3366       'participant_id' => $participant['id'],
3367     );
3368     foreach ($priceFields['values'] as $key => $priceField) {
3369       $lineItems[1][$key] = array(
3370         'price_field_id' => $priceField['price_field_id'],
3371         'price_field_value_id' => $priceField['id'],
3372         'label' => $priceField['label'],
3373         'field_title' => $priceField['label'],
3374         'qty' => 1,
3375         'unit_price' => $priceField['amount'],
3376         'line_total' => $priceField['amount'],
3377         'financial_type_id' => $priceField['financial_type_id'],
3378       );
3379     }
3380     $contributionParams['line_item'] = $lineItems;
3381     $contribution = $this->callAPISuccess('Contribution', 'create', $contributionParams);
3382     $paymentParticipant = array(
3383       'participant_id' => $participant['id'],
3384       'contribution_id' => $contribution['id'],
3385     );
3386     $ids = array();
3387     $this->callAPISuccess('ParticipantPayment', 'create', $paymentParticipant);
3388     return array($lineItems, $contribution);
3389   }
3390
3391   /**
3392    * Create price set
3393    *
3394    * @param string $component
3395    * @param int $componentId
3396    *
3397    * @return array
3398    */
3399   protected function createPriceSet($component = 'contribution_page', $componentId = NULL) {
3400     $paramsSet['title'] = 'Price Set' . substr(sha1(rand()), 0, 7);
3401     $paramsSet['name'] = CRM_Utils_String::titleToVar($paramsSet['title']);
3402     $paramsSet['is_active'] = TRUE;
3403     $paramsSet['financial_type_id'] = 4;
3404     $paramsSet['extends'] = 1;
3405     $priceSet = $this->callAPISuccess('price_set', 'create', $paramsSet);
3406     $priceSetId = $priceSet['id'];
3407     //Checking for priceset added in the table.
3408     $this->assertDBCompareValue('CRM_Price_BAO_PriceSet', $priceSetId, 'title',
3409       'id', $paramsSet['title'], 'Check DB for created priceset'
3410     );
3411     $paramsField = array(
3412       'label' => 'Price Field',
3413       'name' => CRM_Utils_String::titleToVar('Price Field'),
3414       'html_type' => 'CheckBox',
3415       'option_label' => array('1' => 'Price Field 1', '2' => 'Price Field 2'),
3416       'option_value' => array('1' => 100, '2' => 200),
3417       'option_name' => array('1' => 'Price Field 1', '2' => 'Price Field 2'),
3418       'option_weight' => array('1' => 1, '2' => 2),
3419       'option_amount' => array('1' => 100, '2' => 200),
3420       'is_display_amounts' => 1,
3421       'weight' => 1,
3422       'options_per_line' => 1,
3423       'is_active' => array('1' => 1, '2' => 1),
3424       'price_set_id' => $priceSet['id'],
3425       'is_enter_qty' => 1,
3426       'financial_type_id' => $this->getFinancialTypeId('Event Fee'),
3427     );
3428     $priceField = CRM_Price_BAO_PriceField::create($paramsField);
3429     if ($componentId) {
3430       CRM_Price_BAO_PriceSet::addTo('civicrm_' . $component, $componentId, $priceSetId);
3431     }
3432     return $this->callAPISuccess('PriceFieldValue', 'get', array('price_field_id' => $priceField->id));
3433   }
3434
3435   /**
3436    * Replace the template with a test-oriented template designed to show all the variables.
3437    *
3438    * @param string $templateName
3439    */
3440   protected function swapMessageTemplateForTestTemplate($templateName = 'contribution_online_receipt') {
3441     $testTemplate = file_get_contents(__DIR__ . '/../../templates/message_templates/' . $templateName . '_html.tpl');
3442     CRM_Core_DAO::executeQuery(
3443       "UPDATE civicrm_option_group og
3444       LEFT JOIN civicrm_option_value ov ON ov.option_group_id = og.id
3445       LEFT JOIN civicrm_msg_template m ON m.workflow_id = ov.id
3446       SET m.msg_html = '{$testTemplate}'
3447       WHERE og.name = 'msg_tpl_workflow_contribution'
3448       AND ov.name = '{$templateName}'
3449       AND m.is_default = 1"
3450     );
3451   }
3452
3453   /**
3454    * Reinstate the default template.
3455    *
3456    * @param string $templateName
3457    */
3458   protected function revertTemplateToReservedTemplate($templateName = 'contribution_online_receipt') {
3459     CRM_Core_DAO::executeQuery(
3460       "UPDATE civicrm_option_group og
3461       LEFT JOIN civicrm_option_value ov ON ov.option_group_id = og.id
3462       LEFT JOIN civicrm_msg_template m ON m.workflow_id = ov.id
3463       LEFT JOIN civicrm_msg_template m2 ON m2.workflow_id = ov.id AND m2.is_reserved = 1
3464       SET m.msg_html = m2.msg_html
3465       WHERE og.name = 'msg_tpl_workflow_contribution'
3466       AND ov.name = '{$templateName}'
3467       AND m.is_default = 1"
3468     );
3469   }
3470
3471   /**
3472    * Flush statics relating to financial type.
3473    */
3474   protected function flushFinancialTypeStatics() {
3475     if (isset(\Civi::$statics['CRM_Financial_BAO_FinancialType'])) {
3476       unset(\Civi::$statics['CRM_Financial_BAO_FinancialType']);
3477     }
3478     if (isset(\Civi::$statics['CRM_Contribute_PseudoConstant'])) {
3479       unset(\Civi::$statics['CRM_Contribute_PseudoConstant']);
3480     }
3481     CRM_Contribute_PseudoConstant::flush('financialType');
3482     CRM_Contribute_PseudoConstant::flush('membershipType');
3483     // Pseudoconstants may be saved to the cache table.
3484     CRM_Core_DAO::executeQuery("TRUNCATE civicrm_cache");
3485     CRM_Financial_BAO_FinancialType::$_statusACLFt = array();
3486     CRM_Financial_BAO_FinancialType::$_availableFinancialTypes = NULL;
3487   }
3488
3489   /**
3490    * Set the permissions to the supplied array.
3491    *
3492    * @param array $permissions
3493    */
3494   protected function setPermissions($permissions) {
3495     CRM_Core_Config::singleton()->userPermissionClass->permissions = $permissions;
3496     $this->flushFinancialTypeStatics();
3497     CRM_Contact_BAO_Group::getPermissionClause(TRUE);
3498   }
3499
3500   /**
3501    * @param array $params
3502    * @param $context
3503    */
3504   public function _checkFinancialRecords($params, $context) {
3505     $entityParams = array(
3506       'entity_id' => $params['id'],
3507       'entity_table' => 'civicrm_contribution',
3508     );
3509     $contribution = $this->callAPISuccess('contribution', 'getsingle', array('id' => $params['id']));
3510     $this->assertEquals($contribution['total_amount'] - $contribution['fee_amount'], $contribution['net_amount']);
3511     if ($context == 'pending') {
3512       $trxn = CRM_Financial_BAO_FinancialItem::retrieveEntityFinancialTrxn($entityParams);
3513       $this->assertNull($trxn, 'No Trxn to be created until IPN callback');
3514       return;
3515     }
3516     $trxn = current(CRM_Financial_BAO_FinancialItem::retrieveEntityFinancialTrxn($entityParams));
3517     $trxnParams = array(
3518       'id' => $trxn['financial_trxn_id'],
3519     );
3520     if ($context != 'online' && $context != 'payLater') {
3521       $compareParams = array(
3522         'to_financial_account_id' => 6,
3523         'total_amount' => CRM_Utils_Array::value('total_amount', $params, 100),
3524         'status_id' => 1,
3525       );
3526     }
3527     if ($context == 'feeAmount') {
3528       $compareParams['fee_amount'] = 50;
3529     }
3530     elseif ($context == 'online') {
3531       $compareParams = array(
3532         'to_financial_account_id' => 12,
3533         'total_amount' => CRM_Utils_Array::value('total_amount', $params, 100),
3534         'status_id' => 1,
3535         'payment_instrument_id' => 1,
3536       );
3537     }
3538     elseif ($context == 'payLater') {
3539       $compareParams = array(
3540         'to_financial_account_id' => 7,
3541         'total_amount' => CRM_Utils_Array::value('total_amount', $params, 100),
3542         'status_id' => 2,
3543       );
3544     }
3545     $this->assertDBCompareValues('CRM_Financial_DAO_FinancialTrxn', $trxnParams, $compareParams);
3546     $entityParams = array(
3547       'financial_trxn_id' => $trxn['financial_trxn_id'],
3548       'entity_table' => 'civicrm_financial_item',
3549     );
3550     $entityTrxn = current(CRM_Financial_BAO_FinancialItem::retrieveEntityFinancialTrxn($entityParams));
3551     $fitemParams = array(
3552       'id' => $entityTrxn['entity_id'],
3553     );
3554     $compareParams = array(
3555       'amount' => CRM_Utils_Array::value('total_amount', $params, 100),
3556       'status_id' => 1,
3557       'financial_account_id' => CRM_Utils_Array::value('financial_account_id', $params, 1),
3558     );
3559     if ($context == 'payLater') {
3560       $compareParams = array(
3561         'amount' => CRM_Utils_Array::value('total_amount', $params, 100),
3562         'status_id' => 3,
3563         'financial_account_id' => CRM_Utils_Array::value('financial_account_id', $params, 1),
3564       );
3565     }
3566     $this->assertDBCompareValues('CRM_Financial_DAO_FinancialItem', $fitemParams, $compareParams);
3567     if ($context == 'feeAmount') {
3568       $maxParams = array(
3569         'entity_id' => $params['id'],
3570         'entity_table' => 'civicrm_contribution',
3571       );
3572       $maxTrxn = current(CRM_Financial_BAO_FinancialItem::retrieveEntityFinancialTrxn($maxParams, TRUE));
3573       $trxnParams = array(
3574         'id' => $maxTrxn['financial_trxn_id'],
3575       );
3576       $compareParams = array(
3577         'to_financial_account_id' => 5,
3578         'from_financial_account_id' => 6,
3579         'total_amount' => 50,
3580         'status_id' => 1,
3581       );
3582       $trxnId = CRM_Core_BAO_FinancialTrxn::getFinancialTrxnId($params['id'], 'DESC');
3583       $this->assertDBCompareValues('CRM_Financial_DAO_FinancialTrxn', $trxnParams, $compareParams);
3584       $fitemParams = array(
3585         'entity_id' => $trxnId['financialTrxnId'],
3586         'entity_table' => 'civicrm_financial_trxn',
3587       );
3588       $compareParams = array(
3589         'amount' => 50,
3590         'status_id' => 1,
3591         'financial_account_id' => 5,
3592       );
3593       $this->assertDBCompareValues('CRM_Financial_DAO_FinancialItem', $fitemParams, $compareParams);
3594     }
3595     // This checks that empty Sales tax rows are not being created. If for any reason it needs to be removed the
3596     // line should be copied into all the functions that call this function & evaluated there
3597     // Be really careful not to remove or bypass this without ensuring stray rows do not re-appear
3598     // when calling completeTransaction or repeatTransaction.
3599     $this->callAPISuccessGetCount('FinancialItem', array('description' => 'Sales Tax', 'amount' => 0), 0);
3600   }
3601
3602   /**
3603    * Return financial type id on basis of name
3604    *
3605    * @param string $name Financial type m/c name
3606    *
3607    * @return int
3608    */
3609   public function getFinancialTypeId($name) {
3610     return CRM_Core_DAO::getFieldValue('CRM_Financial_DAO_FinancialType', $name, 'id', 'name');
3611   }
3612
3613   /**
3614    * Cleanup function for contents of $this->ids.
3615    *
3616    * This is a best effort cleanup to use in tear downs etc.
3617    *
3618    * It will not fail if the data has already been removed (some tests may do
3619    * their own cleanup).
3620    */
3621   protected function cleanUpSetUpIDs() {
3622     foreach ($this->setupIDs as $entity => $id) {
3623       try {
3624         civicrm_api3($entity, 'delete', array('id' => $id, 'skip_undelete' => 1));
3625       }
3626       catch (CiviCRM_API3_Exception $e) {
3627         // This is a best-effort cleanup function, ignore.
3628       }
3629     }
3630   }
3631
3632 }