Civi/Test/Api3TestTrait.php

   1 <?php
   2
   3 namespace Civi\Test;
   4
   5 use Civi\API\Exception\NotImplementedException;
   6
   7 require_once 'api/v3/utils.php';
   8 /**
   9  * Class Api3TestTrait
  10  * @package Civi\Test
  11  *
  12  * This trait defines a number of helper functions for testing APIv3. Commonly
  13  * used helpers include `callAPISuccess()`, `callAPIFailure()`,
  14  * `assertAPISuccess()`, and `assertAPIFailure()`.
  15  *
  16  * This trait is intended for use with PHPUnit-based test cases.
  17  */
  18 trait Api3TestTrait {
  19
  20   /**
  21    * Get the api versions to test.
  22    *
  23    * @return array
  24    */
  25   public function versionThreeAndFour() {
  26     return [
  27       'APIv3' => [3],
  28       'APIv4' => [4],
  29     ];
  30   }
  31
  32   /**
  33    * Api version - easier to override than just a define
  34    * @var int
  35    */
  36   protected $_apiversion = 3;
  37
  38   /**
  39    * Check that api returned 'is_error' => 1
  40    * else provide full message
  41    * @param array $result
  42    * @param $expected
  43    * @param array $valuesToExclude
  44    * @param string $prefix
  45    *   Extra test to add to message.
  46    */
  47   public function assertAPIArrayComparison($result, $expected, $valuesToExclude = [], $prefix = '') {
  48     $valuesToExclude = array_merge($valuesToExclude, ['debug', 'xdebug', 'sequential']);
  49     foreach ($valuesToExclude as $value) {
  50       if (isset($result[$value])) {
  51         unset($result[$value]);
  52       }
  53       if (isset($expected[$value])) {
  54         unset($expected[$value]);
  55       }
  56     }
  57     $this->assertEquals($result, $expected, "api result array comparison failed " . $prefix . print_r($result, TRUE) . ' was compared to ' . print_r($expected, TRUE));
  58   }
  59
  60   /**
  61    * Check that a deleted item has been deleted.
  62    *
  63    * @param $entity
  64    * @param $id
  65    */
  66   public function assertAPIDeleted($entity, $id) {
  67     $this->callAPISuccess($entity, 'getcount', ['id' => $id], 0);
  68   }
  69
  70   /**
  71    * Check that api returned 'is_error' => 1.
  72    *
  73    * @param array $apiResult
  74    *   Api result.
  75    * @param string $prefix
  76    *   Extra test to add to message.
  77    * @param null $expectedError
  78    */
  79   public function assertAPIFailure($apiResult, $prefix = '', $expectedError = NULL) {
  80     if (!empty($prefix)) {
  81       $prefix .= ': ';
  82     }
  83     if ($expectedError && !empty($apiResult['is_error'])) {
  84       $this->assertStringContainsString($expectedError, $apiResult['error_message'], 'api error message not as expected' . $prefix);
  85     }
  86     $this->assertEquals(1, $apiResult['is_error'], "api call should have failed but it succeeded " . $prefix . (print_r($apiResult, TRUE)));
  87     $this->assertNotEmpty($apiResult['error_message']);
  88   }
  89
  90   /**
  91    * Check that api returned 'is_error' => 0.
  92    *
  93    * @param array $apiResult
  94    *   Api result.
  95    * @param string $prefix
  96    *   Extra test to add to message.
  97    */
  98   public function assertAPISuccess($apiResult, $prefix = '') {
  99     if (!empty($prefix)) {
 100       $prefix .= ': ';
 101     }
 102     $errorMessage = empty($apiResult['error_message']) ? '' : " " . $apiResult['error_message'];
 103
 104     if (!empty($apiResult['debug_information'])) {
 105       $errorMessage .= "\n " . print_r($apiResult['debug_information'], TRUE);
 106     }
 107     if (!empty($apiResult['trace'])) {
 108       $errorMessage .= "\n" . print_r($apiResult['trace'], TRUE);
 109     }
 110     $this->assertEmpty($apiResult['is_error'] ?? NULL, $prefix . $errorMessage);
 111   }
 112
 113   /**
 114    * This function exists to wrap api functions.
 115    * so we can ensure they fail where expected & throw exceptions without litterering the test with checks
 116    * @param string $entity
 117    * @param string $action
 118    * @param array $params
 119    * @param string $expectedErrorMessage
 120    *   Error.
 121    * @param null $extraOutput
 122    * @return array|int
 123    */
 124   public function callAPIFailure($entity, $action, $params, $expectedErrorMessage = NULL, $extraOutput = NULL) {
 125     if (is_array($params)) {
 126       $params += [
 127         'version' => $this->_apiversion,
 128       ];
 129     }
 130     try {
 131       $result = $this->civicrm_api($entity, $action, $params);
 132     }
 133     catch (\API_Exception $e) {
 134       // api v4 call failed and threw an exception.
 135       return [];
 136     }
 137     $this->assertAPIFailure($result, "We expected a failure for $entity $action but got a success", $expectedErrorMessage);
 138     return $result;
 139   }
 140
 141   /**
 142    * wrap api functions.
 143    * so we can ensure they succeed & throw exceptions without litterering the test with checks
 144    *
 145    * @param string $entity
 146    * @param string $action
 147    * @param array $params
 148    * @param mixed $checkAgainst
 149    *   Optional value to check result against, implemented for getvalue,.
 150    *   getcount, getsingle. Note that for getvalue the type is checked rather than the value
 151    *   for getsingle the array is compared against an array passed in - the id is not compared (for
 152    *   better or worse )
 153    *
 154    * @return array|int
 155    *
 156    * @throws \CRM_Core_Exception
 157    */
 158   public function callAPISuccess($entity, $action, $params = [], $checkAgainst = NULL) {
 159     $params = array_merge([
 160       'version' => $this->_apiversion,
 161       'debug' => 1,
 162     ],
 163       $params
 164     );
 165     switch (strtolower($action)) {
 166       case 'getvalue':
 167         return $this->callAPISuccessGetValue($entity, $params, $checkAgainst);
 168
 169       case 'getsingle':
 170         return $this->callAPISuccessGetSingle($entity, $params, $checkAgainst);
 171
 172       case 'getcount':
 173         return $this->callAPISuccessGetCount($entity, $params, $checkAgainst);
 174     }
 175     $result = $this->civicrm_api($entity, $action, $params);
 176     $this->assertAPISuccess($result, "Failure in api call for $entity $action");
 177     return $result;
 178   }
 179
 180   /**
 181    * This function exists to wrap api getValue function & check the result
 182    * so we can ensure they succeed & throw exceptions without littering the test with checks
 183    * There is a type check in this
 184    *
 185    * @param string $entity
 186    * @param array $params
 187    * @param int $count
 188    *
 189    * @throws \CRM_Core_Exception
 190    *
 191    * @return array|int
 192    */
 193   public function callAPISuccessGetCount($entity, $params, $count = NULL) {
 194     $params += [
 195       'version' => $this->_apiversion,
 196       'debug' => 1,
 197     ];
 198     $result = $this->civicrm_api($entity, 'getcount', $params);
 199     if (!is_int($result) || !empty($result['is_error']) || isset($result['values'])) {
 200       throw new \CRM_Core_Exception('Invalid getcount result : ' . print_r($result, TRUE) . " type :" . gettype($result));
 201     }
 202     if (is_int($count)) {
 203       $this->assertEquals($count, $result, "incorrect count returned from $entity getcount");
 204     }
 205     return $result;
 206   }
 207
 208   /**
 209    * This function exists to wrap api getsingle function & check the result
 210    * so we can ensure they succeed & throw exceptions without litterering the test with checks
 211    *
 212    * @param string $entity
 213    * @param array $params
 214    * @param array $checkAgainst
 215    *   Array to compare result against.
 216    *   - boolean
 217    *   - integer
 218    *   - double
 219    *   - string
 220    *   - array
 221    *   - object
 222    *
 223    * @throws \CRM_Core_Exception
 224    *
 225    * @return array|int
 226    */
 227   public function callAPISuccessGetSingle($entity, $params, $checkAgainst = NULL) {
 228     $params += [
 229       'version' => $this->_apiversion,
 230     ];
 231     if (!empty($this->isGetSafe) && !isset($params['return'])) {
 232       $params['return'] = 'id';
 233     }
 234     $result = $this->civicrm_api($entity, 'getsingle', $params);
 235     if (!is_array($result) || !empty($result['is_error']) || isset($result['values'])) {
 236       $unfilteredResult = $this->civicrm_api($entity, 'get', ['version' => $this->_apiversion]);
 237       throw new \CRM_Core_Exception(
 238         'Invalid getsingle result' . print_r($result, TRUE)
 239         . "\n entity: $entity . \n params \n " . print_r($params, TRUE)
 240         . "\n entities retrieved with blank params \n" . print_r($unfilteredResult, TRUE)
 241       );
 242     }
 243     if ($checkAgainst) {
 244       // @todo - have gone with the fn that unsets id? should we check id?
 245       $this->checkArrayEquals($result, $checkAgainst);
 246     }
 247     return $result;
 248   }
 249
 250   /**
 251    * This function exists to wrap api getValue function & check the result
 252    * so we can ensure they succeed & throw exceptions without litterering the test with checks
 253    * There is a type check in this
 254    *
 255    * @param string $entity
 256    * @param array $params
 257    * @param string $type
 258    *   Per http://php.net/manual/en/function.gettype.php possible types.
 259    *   - boolean
 260    *   - integer
 261    *   - double
 262    *   - string
 263    *   - array
 264    *   - object
 265    *
 266    * @return array|int
 267    * @throws \CRM_Core_Exception
 268    */
 269   public function callAPISuccessGetValue($entity, $params, $type = NULL) {
 270     $params += [
 271       'version' => $this->_apiversion,
 272     ];
 273     $result = $this->civicrm_api($entity, 'getvalue', $params);
 274     if (is_array($result) && (!empty($result['is_error']) || isset($result['values']))) {
 275       throw new \CRM_Core_Exception('Invalid getvalue result' . print_r($result, TRUE));
 276     }
 277     if ($type) {
 278       if ($type === 'integer') {
 279         // api seems to return integers as strings
 280         $this->assertTrue(is_numeric($result), "expected a numeric value but got " . print_r($result, 1));
 281       }
 282       else {
 283         $this->assertType($type, $result, "returned result should have been of type $type but was ");
 284       }
 285     }
 286     return $result;
 287   }
 288
 289   /**
 290    * A stub for the API interface. This can be overriden by subclasses to change how the API is called.
 291    *
 292    * @param $entity
 293    * @param $action
 294    * @param array $params
 295    * @return array|int
 296    */
 297   public function civicrm_api($entity, $action, $params = []) {
 298     if (($params['version'] ?? 0) == 4) {
 299       return $this->runApi4Legacy($entity, $action, $params);
 300     }
 301     return civicrm_api($entity, $action, $params);
 302   }
 303
 304   /**
 305    * Emulate v3 syntax so we can run api3 tests on v4
 306    *
 307    * @param $v3Entity
 308    * @param $v3Action
 309    * @param array $v3Params
 310    * @return array|int
 311    * @throws \API_Exception
 312    * @throws \CiviCRM_API3_Exception
 313    * @throws \Exception
 314    */
 315   public function runApi4Legacy($v3Entity, $v3Action, $v3Params = []) {
 316     $v4Entity = \CRM_Core_DAO_AllCoreTables::convertEntityNameToCamel($v3Entity);
 317     $v4Action = $v3Action = strtolower($v3Action);
 318     $v4Params = ['checkPermissions' => isset($v3Params['check_permissions']) ? (bool) $v3Params['check_permissions'] : FALSE];
 319     $sequential = !empty($v3Params['sequential']);
 320     $options = \_civicrm_api3_get_options_from_params($v3Params, in_array($v4Entity, ['Contact', 'Participant', 'Event', 'Group', 'Contribution', 'Membership']));
 321     $indexBy = in_array($v3Action, ['get', 'create', 'replace']) && !$sequential ? 'id' : NULL;
 322     $onlyId = !empty($v3Params['format.only_id']);
 323     $onlySuccess = !empty($v3Params['format.is_success']);
 324     if (!empty($v3Params['filters']['is_current']) || !empty($v3Params['isCurrent'])) {
 325       $v4Params['current'] = TRUE;
 326     }
 327     $language = $v3Params['options']['language'] ?? $v3Params['option.language'] ?? NULL;
 328     if ($language) {
 329       $v4Params['language'] = $language;
 330     }
 331     $toRemove = ['option.', 'return', 'api.', 'format.'];
 332     $chains = $joins = $custom = [];
 333     foreach ($v3Params as $key => $val) {
 334       foreach ($toRemove as $remove) {
 335         if (strpos($key, $remove) === 0) {
 336           if ($remove == 'api.') {
 337             $chains[$key] = $val;
 338           }
 339           unset($v3Params[$key]);
 340         }
 341       }
 342     }
 343
 344     $v3Fields = civicrm_api3($v3Entity, 'getfields', ['action' => $v3Action])['values'];
 345
 346     // Fix 'null'
 347     foreach ($v3Params as $key => $val) {
 348       if ($val === 'null') {
 349         $v3Params[$key] = NULL;
 350       }
 351     }
 352
 353     if ($v4Entity == 'Setting') {
 354       $indexBy = NULL;
 355       $v4Params['domainId'] = $v3Params['domain_id'] ?? NULL;
 356       if ($v3Action == 'getfields') {
 357         if (!empty($v3Params['name'])) {
 358           $v3Params['filters']['name'] = $v3Params['name'];
 359         }
 360         foreach ($v3Params['filters'] ?? [] as $filter => $val) {
 361           $v4Params['where'][] = [$filter, '=', $val];
 362         }
 363       }
 364       if ($v3Action == 'create') {
 365         $v4Action = 'set';
 366       }
 367       if ($v3Action == 'revert') {
 368         $v4Params['select'] = (array) $v3Params['name'];
 369       }
 370       if ($v3Action == 'getvalue') {
 371         $options['return'] = [$v3Params['name'] => 1];
 372         $v3Params = [];
 373       }
 374       \CRM_Utils_Array::remove($v3Params, 'domain_id', 'name');
 375     }
 376
 377     \CRM_Utils_Array::remove($v3Params, 'options', 'debug', 'version', 'sort', 'offset', 'rowCount', 'check_permissions', 'sequential', 'filters', 'isCurrent');
 378
 379     // Work around ugly hack in v3 Domain api
 380     if ($v4Entity == 'Domain') {
 381       $v3Fields['version'] = ['name' => 'version', 'api.aliases' => ['domain_version']];
 382       unset($v3Fields['domain_version']);
 383     }
 384
 385     foreach ($v3Fields as $name => $field) {
 386       // Resolve v3 aliases
 387       foreach ($field['api.aliases'] ?? [] as $alias) {
 388         if (isset($v3Params[$alias])) {
 389           $v3Params[$field['name']] = $v3Params[$alias];
 390           unset($v3Params[$alias]);
 391         }
 392       }
 393       // Convert custom field names
 394       if (strpos($name, 'custom_') === 0 && is_numeric($name[7])) {
 395         // Strictly speaking, using titles instead of names is incorrect, but it works for
 396         // unit tests where names and titles are identical and saves an extra db lookup.
 397         $custom[$field['groupTitle']][$field['title']] = $name;
 398         $v4FieldName = $field['groupTitle'] . '.' . $field['title'];
 399         if (isset($v3Params[$name])) {
 400           $v3Params[$v4FieldName] = $v3Params[$name];
 401           unset($v3Params[$name]);
 402         }
 403         if (isset($options['return'][$name])) {
 404           $options['return'][$v4FieldName] = 1;
 405           unset($options['return'][$name]);
 406         }
 407       }
 408
 409       if ($name === 'option_group_id' && isset($v3Params[$name]) && !is_numeric($v3Params[$name])) {
 410         // This is a per field hack (bad) but we can't solve everything at once
 411         // & a cleverer way turned out to be too much for this round.
 412         // Being in the test class it's tested....
 413         $v3Params['option_group.name'] = $v3Params['option_group_id'];
 414         unset($v3Params['option_group_id']);
 415       }
 416       if (isset($field['pseudoconstant'], $v3Params[$name]) && $field['type'] === \CRM_Utils_Type::T_INT && !is_numeric($v3Params[$name]) && is_string($v3Params[$name])) {
 417         $v3Params[$name] = \CRM_Core_PseudoConstant::getKey(\CRM_Core_DAO_AllCoreTables::getFullName($v4Entity), $name, $v3Params[$name]);
 418       }
 419     }
 420
 421     switch ($v3Action) {
 422       case 'getcount':
 423         $v4Params['select'] = ['row_count'];
 424         // No break - keep processing as get
 425       case 'getsingle':
 426       case 'getvalue':
 427         $v4Action = 'get';
 428         // No break - keep processing as get
 429       case 'get':
 430         if ($options['return'] && $v3Action !== 'getcount') {
 431           $v4Params['select'] = array_keys($options['return']);
 432           // Ensure id field is returned as v3 always expects it
 433           if ($v4Entity != 'Setting' && !in_array('id', $v4Params['select'])) {
 434             $v4Params['select'][] = 'id';
 435           }
 436           // Convert join syntax
 437           foreach ($v4Params['select'] as $idx => $select) {
 438             if (strstr($select, '_id.')) {
 439               $joins[$select] = $v4Params['select'][$idx] = str_replace('_id.', '.', $select);
 440             }
 441           }
 442         }
 443         if ($options['limit'] && $v4Entity != 'Setting') {
 444           $v4Params['limit'] = $options['limit'];
 445         }
 446         if ($options['offset']) {
 447           $v4Params['offset'] = $options['offset'];
 448         }
 449         if ($options['sort']) {
 450           foreach (explode(',', $options['sort']) as $sort) {
 451             [$sortField, $sortDir] = array_pad(explode(' ', trim($sort)), 2, 'ASC');
 452             $v4Params['orderBy'][$sortField] = $sortDir;
 453           }
 454         }
 455         break;
 456
 457       case 'replace':
 458         if (empty($v3Params['values'])) {
 459           $v4Action = 'delete';
 460         }
 461         else {
 462           $v4Params['records'] = $v3Params['values'];
 463         }
 464         unset($v3Params['values']);
 465         break;
 466
 467       case 'create':
 468       case 'update':
 469         if (!empty($v3Params['id'])) {
 470           $v4Action = 'update';
 471           $v4Params['where'][] = ['id', '=', $v3Params['id']];
 472         }
 473
 474         $v4Params['values'] = $v3Params;
 475         unset($v4Params['values']['id']);
 476         break;
 477
 478       case 'delete':
 479         if (isset($v3Params['id'])) {
 480           $v4Params['where'][] = ['id', '=', $v3Params['id']];
 481         }
 482         break;
 483
 484       case 'getoptions':
 485         $indexBy = 0;
 486         $v4Action = 'getFields';
 487         $v4Params += [
 488           'where' => [['name', '=', $v3Params['field']]],
 489           'loadOptions' => TRUE,
 490         ];
 491         break;
 492
 493       case 'getfields':
 494         $v4Action = 'getFields';
 495         if (!empty($v3Params['action']) || !empty($v3Params['api_action'])) {
 496           $v4Params['action'] = !empty($v3Params['action']) ? $v3Params['action'] : $v3Params['api_action'];
 497         }
 498         $indexBy = !$sequential ? 'name' : NULL;
 499         break;
 500     }
 501
 502     // Ensure this api4 entity/action exists
 503     try {
 504       $actionInfo = \civicrm_api4($v4Entity, 'getActions', ['checkPermissions' => FALSE, 'where' => [['name', '=', $v4Action]]]);
 505     }
 506     catch (NotImplementedException $e) {
 507       // For now we'll mark the test incomplete if a v4 entity doesn't exit yet
 508       $this->markTestIncomplete($e->getMessage());
 509     }
 510     if (!isset($actionInfo[0])) {
 511       throw new \Exception("Api4 $v4Entity $v4Action does not exist.");
 512     }
 513
 514     // Migrate special params like fix_address
 515     foreach ($actionInfo[0]['params'] as $v4ParamName => $paramInfo) {
 516       // camelCase in api4, lower_case in api3
 517       $v3ParamName = strtolower(preg_replace('/(?=[A-Z])/', '_$0', $v4ParamName));
 518       if (isset($v3Params[$v3ParamName])) {
 519         $v4Params[$v4ParamName] = $v3Params[$v3ParamName];
 520         unset($v3Params[$v3ParamName]);
 521         if ($paramInfo['type'][0] == 'bool') {
 522           $v4Params[$v4ParamName] = (bool) $v4Params[$v4ParamName];
 523         }
 524       }
 525     }
 526
 527     // Build where clause for 'getcount', 'getsingle', 'getvalue', 'get' & 'replace'
 528     if ($v4Action == 'get' || $v3Action == 'replace') {
 529       foreach ($v3Params as $key => $val) {
 530         $op = '=';
 531         if (is_array($val) && count($val) == 1 && array_intersect_key($val, array_flip(\CRM_Core_DAO::acceptedSQLOperators()))) {
 532           foreach ($val as $op => $newVal) {
 533             $val = $newVal;
 534           }
 535         }
 536         $v4Params['where'][] = [$key, $op, $val];
 537       }
 538     }
 539
 540     try {
 541       $result = \civicrm_api4($v4Entity, $v4Action, $v4Params, $indexBy);
 542     }
 543     catch (\Exception $e) {
 544       return $onlySuccess ? 0 : [
 545         'is_error' => 1,
 546         'error_message' => $e->getMessage(),
 547         'version' => 4,
 548       ];
 549     }
 550
 551     if (($v3Action == 'getsingle' || $v3Action == 'getvalue' || $v3Action == 'delete') && count($result) != 1) {
 552       return $onlySuccess ? 0 : [
 553         'is_error' => 1,
 554         'error_message' => "Expected one $v4Entity but found " . count($result),
 555         'count' => count($result),
 556       ];
 557     }
 558
 559     if ($onlySuccess) {
 560       return 1;
 561     }
 562
 563     if ($v3Action == 'getcount') {
 564       return $result->count();
 565     }
 566
 567     if ($onlyId) {
 568       return $result->first()['id'];
 569     }
 570
 571     if ($v3Action == 'getvalue' && $v4Entity == 'Setting') {
 572       return $result->first()['value'] ?? NULL;
 573     }
 574
 575     if ($v3Action == 'getvalue') {
 576       $returnKey = array_keys($options['return'])[0];
 577       return $result->first()[$returnKey] ?? NULL;
 578     }
 579
 580     // Mimic api3 behavior when using 'replace' action to delete all
 581     if ($v3Action == 'replace' && $v4Action == 'delete') {
 582       $result->exchangeArray([]);
 583     }
 584
 585     if ($v3Action == 'getoptions') {
 586       return [
 587         'is_error' => 0,
 588         'count' => $result['options'] ? count($result['options']) : 0,
 589         'values' => $result['options'] ?: [],
 590         'version' => 4,
 591       ];
 592     }
 593
 594     // Emulate the weird return format of api3 settings
 595     if (($v3Action == 'get' || $v3Action == 'create') && $v4Entity == 'Setting') {
 596       $settings = [];
 597       foreach ($result as $item) {
 598         $settings[$item['domain_id']][$item['name']] = $item['value'];
 599       }
 600       $result->exchangeArray($sequential ? array_values($settings) : $settings);
 601     }
 602
 603     foreach ($result as $index => $row) {
 604       // Run chains
 605       foreach ($chains as $key => $params) {
 606         $result[$index][$key] = $this->runApi4LegacyChain($key, $params, $v4Entity, $row, $sequential);
 607       }
 608       // Convert join format
 609       foreach ($joins as $api3Key => $api4Key) {
 610         $result[$index][$api3Key] = $result[$index][$api4Key] ?? NULL;
 611       }
 612       // Resolve custom field names
 613       foreach ($custom as $group => $fields) {
 614         foreach ($fields as $field => $v3FieldName) {
 615           if (isset($row["$group.$field"])) {
 616             $result[$index][$v3FieldName] = $row["$group.$field"];
 617             unset($result[$index]["$group.$field"]);
 618           }
 619         }
 620       }
 621     }
 622
 623     if ($v3Action == 'getsingle') {
 624       return $result->first();
 625     }
 626
 627     return [
 628       'is_error' => 0,
 629       'version' => 4,
 630       'count' => count($result),
 631       'values' => (array) $result,
 632       'id' => is_object($result) && count($result) == 1 ? ($result->first()['id'] ?? NULL) : NULL,
 633     ];
 634   }
 635
 636   /**
 637    * @param string $key
 638    * @param mixed $params
 639    * @param string $mainEntity
 640    * @param array $result
 641    * @param bool $sequential
 642    * @return array
 643    * @throws \API_Exception
 644    */
 645   protected function runApi4LegacyChain($key, $params, $mainEntity, $result, $sequential) {
 646     // Handle an array of multiple calls using recursion
 647     if (is_array($params) && isset($params[0]) && is_array($params[0])) {
 648       $results = [];
 649       foreach ($params as $chain) {
 650         $results[] = $this->runApi4LegacyChain($key, $chain, $mainEntity, $result, $sequential);
 651       }
 652       return $results;
 653     }
 654
 655     // Handle single api call
 656     list(, $chainEntity, $chainAction) = explode('.', $key);
 657     $lcChainEntity = \CRM_Core_DAO_AllCoreTables::convertEntityNameToLower($chainEntity);
 658     $chainEntity = \CRM_Core_DAO_AllCoreTables::convertEntityNameToCamel($chainEntity);
 659     $lcMainEntity = \CRM_Core_DAO_AllCoreTables::convertEntityNameToLower($mainEntity);
 660     $params = is_array($params) ? $params : [];
 661
 662     // Api3 expects this to be inherited
 663     $params += ['sequential' => $sequential];
 664
 665     // Replace $value.field_name
 666     foreach ($params as $name => $param) {
 667       if (is_string($param) && strpos($param, '$value.') === 0) {
 668         $param = substr($param, 7);
 669         $params[$name] = $result[$param] ?? NULL;
 670       }
 671     }
 672
 673     try {
 674       $getFields = civicrm_api4($chainEntity, 'getFields', ['select' => ['name']], 'name');
 675     }
 676     catch (NotImplementedException $e) {
 677       $this->markTestIncomplete($e->getMessage());
 678     }
 679
 680     // Emulate the string-fu guesswork that api3 does
 681     if ($chainEntity == $mainEntity && empty($params['id']) &&  !empty($result['id'])) {
 682       $params['id'] = $result['id'];
 683     }
 684     elseif (empty($params['id']) && !empty($result[$lcChainEntity . '_id'])) {
 685       $params['id'] = $result[$lcChainEntity . '_id'];
 686     }
 687     elseif (!empty($result['id']) && isset($getFields[$lcMainEntity . '_id']) && empty($params[$lcMainEntity . '_id'])) {
 688       $params[$lcMainEntity . '_id'] = $result['id'];
 689     }
 690     return $this->runApi4Legacy($chainEntity, $chainAction, $params);
 691   }
 692
 693 }