tests/phpunit/CRM/Dedupe/MergerTest.php

   1 <?php
   2
   3 /**
   4  * Class CRM_Dedupe_DedupeMergerTest
   5  * @group headless
   6  */
   7 class CRM_Dedupe_MergerTest extends CiviUnitTestCase {
   8
   9   protected $_groupId;
  10   protected $_contactIds = array();
  11
  12   public function tearDown() {
  13     $this->quickCleanup(array('civicrm_contact', 'civicrm_group_contact', 'civicrm_group'));
  14     parent::tearDown();
  15   }
  16
  17   public function createDupeContacts() {
  18     // create a group to hold contacts, so that dupe checks don't consider any other contacts in the DB
  19     $params = array(
  20       'name'       => 'Test Dupe Merger Group',
  21       'title'      => 'Test Dupe Merger Group',
  22       'domain_id'  => 1,
  23       'is_active'  => 1,
  24       'visibility' => 'Public Pages',
  25     );
  26
  27     $result = $this->callAPISuccess('group', 'create', $params);
  28     $this->_groupId = $result['id'];
  29
  30     // contact data set
  31
  32     // make dupe checks based on based on following contact sets:
  33     // FIRST - LAST - EMAIL
  34     // ---------------------------------
  35     // robin  - hood - robin@example.com
  36     // robin  - hood - robin@example.com
  37     // robin  - hood - hood@example.com
  38     // robin  - dale - robin@example.com
  39     // little - dale - dale@example.com
  40     // little - dale - dale@example.com
  41     // will   - dale - dale@example.com
  42     // will   - dale - will@example.com
  43     // will   - dale - will@example.com
  44     $params = array(
  45       array(
  46         'first_name' => 'robin',
  47         'last_name' => 'hood',
  48         'email' => 'robin@example.com',
  49         'contact_type' => 'Individual',
  50       ),
  51       array(
  52         'first_name' => 'robin',
  53         'last_name' => 'hood',
  54         'email' => 'robin@example.com',
  55         'contact_type' => 'Individual',
  56       ),
  57       array(
  58         'first_name' => 'robin',
  59         'last_name' => 'hood',
  60         'email' => 'hood@example.com',
  61         'contact_type' => 'Individual',
  62       ),
  63       array(
  64         'first_name' => 'robin',
  65         'last_name' => 'dale',
  66         'email' => 'robin@example.com',
  67         'contact_type' => 'Individual',
  68       ),
  69       array(
  70         'first_name' => 'little',
  71         'last_name' => 'dale',
  72         'email' => 'dale@example.com',
  73         'contact_type' => 'Individual',
  74       ),
  75       array(
  76         'first_name' => 'little',
  77         'last_name' => 'dale',
  78         'email' => 'dale@example.com',
  79         'contact_type' => 'Individual',
  80       ),
  81       array(
  82         'first_name' => 'will',
  83         'last_name' => 'dale',
  84         'email' => 'dale@example.com',
  85         'contact_type' => 'Individual',
  86       ),
  87       array(
  88         'first_name' => 'will',
  89         'last_name' => 'dale',
  90         'email' => 'will@example.com',
  91         'contact_type' => 'Individual',
  92       ),
  93       array(
  94         'first_name' => 'will',
  95         'last_name' => 'dale',
  96         'email' => 'will@example.com',
  97         'contact_type' => 'Individual',
  98       ),
  99     );
 100
 101     $count = 1;
 102     foreach ($params as $param) {
 103       $param['version'] = 3;
 104       $contact = civicrm_api('contact', 'create', $param);
 105       $this->_contactIds[$count++] = $contact['id'];
 106
 107       $grpParams = array(
 108         'contact_id' => $contact['id'],
 109         'group_id'   => $this->_groupId,
 110         'version'    => 3,
 111       );
 112       $this->callAPISuccess('group_contact', 'create', $grpParams);
 113     }
 114   }
 115
 116   /**
 117    * Delete all created contacts.
 118    */
 119   public function deleteDupeContacts() {
 120     foreach ($this->_contactIds as $contactId) {
 121       $this->contactDelete($contactId);
 122     }
 123     $this->groupDelete($this->_groupId);
 124   }
 125
 126   /**
 127    * Test the batch merge.
 128    */
 129   public function testBatchMergeSelectedDuplicates() {
 130     $this->createDupeContacts();
 131
 132     // verify that all contacts have been created separately
 133     $this->assertEquals(count($this->_contactIds), 9, 'Check for number of contacts.');
 134
 135     $dao = new CRM_Dedupe_DAO_RuleGroup();
 136     $dao->contact_type = 'Individual';
 137     $dao->name = 'IndividualSupervised';
 138     $dao->is_default = 1;
 139     $dao->find(TRUE);
 140
 141     $foundDupes = CRM_Dedupe_Finder::dupesInGroup($dao->id, $this->_groupId);
 142
 143     // -------------------------------------------------------------------------
 144     // Name and Email (reserved) Matches ( 3 pairs )
 145     // --------------------------------------------------------------------------
 146     // robin  - hood - robin@example.com
 147     // robin  - hood - robin@example.com
 148     // little - dale - dale@example.com
 149     // little - dale - dale@example.com
 150     // will   - dale - will@example.com
 151     // will   - dale - will@example.com
 152     // so 3 pairs for - first + last + mail
 153     $this->assertEquals(count($foundDupes), 3, 'Check Individual-Supervised dupe rule for dupesInGroup().');
 154
 155     // Run dedupe finder as the browser would
 156     $_SERVER['REQUEST_METHOD'] = 'GET'; //avoid invalid key error
 157     $object = new CRM_Contact_Page_DedupeFind();
 158     $object->set('gid', $this->_groupId);
 159     $object->set('rgid', $dao->id);
 160     $object->set('action', CRM_Core_Action::UPDATE);
 161     $object->setEmbedded(TRUE);
 162     @$object->run();
 163
 164     // Retrieve pairs from prev next cache table
 165     $select = array('pn.is_selected' => 'is_selected');
 166     $cacheKeyString = CRM_Dedupe_Merger::getMergeCacheKeyString($dao->id, $this->_groupId);
 167     $pnDupePairs = CRM_Core_BAO_PrevNextCache::retrieve($cacheKeyString, NULL, NULL, 0, 0, $select);
 168
 169     $this->assertEquals(count($foundDupes), count($pnDupePairs), 'Check number of dupe pairs in prev next cache.');
 170
 171     // mark first two pairs as selected
 172     CRM_Core_DAO::singleValueQuery("UPDATE civicrm_prevnext_cache SET is_selected = 1 WHERE id IN ({$pnDupePairs[0]['prevnext_id']}, {$pnDupePairs[1]['prevnext_id']})");
 173
 174     $pnDupePairs = CRM_Core_BAO_PrevNextCache::retrieve($cacheKeyString, NULL, NULL, 0, 0, $select);
 175     $this->assertEquals($pnDupePairs[0]['is_selected'], 1, 'Check if first record in dupe pairs is marked as selected.');
 176     $this->assertEquals($pnDupePairs[0]['is_selected'], 1, 'Check if second record in dupe pairs is marked as selected.');
 177
 178     // batch merge selected dupes
 179     $result = CRM_Dedupe_Merger::batchMerge($dao->id, $this->_groupId, 'safe', TRUE, 5, 1);
 180     $this->assertEquals(count($result['merged']), 2, 'Check number of merged pairs.');
 181
 182     // retrieve pairs from prev next cache table
 183     $pnDupePairs = CRM_Core_BAO_PrevNextCache::retrieve($cacheKeyString, NULL, NULL, 0, 0, $select);
 184     $this->assertEquals(count($pnDupePairs), 1, 'Check number of remaining dupe pairs in prev next cache.');
 185
 186     $this->deleteDupeContacts();
 187   }
 188
 189   /**
 190    * Test the batch merge.
 191    */
 192   public function testBatchMergeAllDuplicates() {
 193     $this->createDupeContacts();
 194
 195     // verify that all contacts have been created separately
 196     $this->assertEquals(count($this->_contactIds), 9, 'Check for number of contacts.');
 197
 198     $dao = new CRM_Dedupe_DAO_RuleGroup();
 199     $dao->contact_type = 'Individual';
 200     $dao->name = 'IndividualSupervised';
 201     $dao->is_default = 1;
 202     $dao->find(TRUE);
 203
 204     $foundDupes = CRM_Dedupe_Finder::dupesInGroup($dao->id, $this->_groupId);
 205
 206     // -------------------------------------------------------------------------
 207     // Name and Email (reserved) Matches ( 3 pairs )
 208     // --------------------------------------------------------------------------
 209     // robin  - hood - robin@example.com
 210     // robin  - hood - robin@example.com
 211     // little - dale - dale@example.com
 212     // little - dale - dale@example.com
 213     // will   - dale - will@example.com
 214     // will   - dale - will@example.com
 215     // so 3 pairs for - first + last + mail
 216     $this->assertEquals(count($foundDupes), 3, 'Check Individual-Supervised dupe rule for dupesInGroup().');
 217
 218     // Run dedupe finder as the browser would
 219     $_SERVER['REQUEST_METHOD'] = 'GET'; //avoid invalid key error
 220     $object = new CRM_Contact_Page_DedupeFind();
 221     $object->set('gid', $this->_groupId);
 222     $object->set('rgid', $dao->id);
 223     $object->set('action', CRM_Core_Action::UPDATE);
 224     $object->setEmbedded(TRUE);
 225     @$object->run();
 226
 227     // Retrieve pairs from prev next cache table
 228     $select = array('pn.is_selected' => 'is_selected');
 229     $cacheKeyString = CRM_Dedupe_Merger::getMergeCacheKeyString($dao->id, $this->_groupId);
 230     $pnDupePairs = CRM_Core_BAO_PrevNextCache::retrieve($cacheKeyString, NULL, NULL, 0, 0, $select);
 231
 232     $this->assertEquals(count($foundDupes), count($pnDupePairs), 'Check number of dupe pairs in prev next cache.');
 233
 234     // batch merge all dupes
 235     $result = CRM_Dedupe_Merger::batchMerge($dao->id, $this->_groupId, 'safe', TRUE, 5, 2);
 236     $this->assertEquals(count($result['merged']), 3, 'Check number of merged pairs.');
 237
 238     // retrieve pairs from prev next cache table
 239     $pnDupePairs = CRM_Core_BAO_PrevNextCache::retrieve($cacheKeyString, NULL, NULL, 0, 0, $select);
 240     $this->assertEquals(count($pnDupePairs), 0, 'Check number of remaining dupe pairs in prev next cache.');
 241
 242     $this->deleteDupeContacts();
 243   }
 244
 245   /**
 246    * The goal of this function is to test that all required tables are returned.
 247    */
 248   public function testGetCidRefs() {
 249     $this->entityCustomGroupWithSingleFieldCreate(__FUNCTION__, 'Contacts');
 250     $this->assertEquals(array_merge($this->getStaticCIDRefs(), $this->getHackedInCIDRef()), CRM_Dedupe_Merger::cidRefs());
 251     $this->assertEquals(array_merge($this->getCalculatedCIDRefs(), $this->getHackedInCIDRef()), CRM_Dedupe_Merger::cidRefs());
 252   }
 253
 254   /**
 255    * Get the list of not-really-cid-refs that are currently hacked in.
 256    *
 257    * This is hacked into getCIDs function.
 258    *
 259    * @return array
 260    */
 261   public function getHackedInCIDRef() {
 262     return array(
 263       'civicrm_entity_tag' => array(
 264         0 => 'entity_id',
 265       ),
 266     );
 267   }
 268
 269   /**
 270    * Test function that gets duplicate pairs.
 271    *
 272    * It turns out there are 2 code paths retrieving this data so my initial focus is on ensuring
 273    * they match.
 274    */
 275   public function testGetMatches() {
 276     $this->setupMatchData();
 277     $pairs = CRM_Dedupe_Merger::getDuplicatePairs(
 278       1,
 279       NULL,
 280       TRUE,
 281       25,
 282       FALSE
 283     );
 284
 285     $this->assertEquals(array(
 286       0 => array(
 287         'srcID' => $this->contacts[1]['id'],
 288         'srcName' => 'Mr. Mickey Mouse II',
 289         'dstID' => $this->contacts[0]['id'],
 290         'dstName' => 'Mr. Mickey Mouse II',
 291         'weight' => 20,
 292         'canMerge' => TRUE,
 293       ),
 294       1 => array(
 295         'srcID' => $this->contacts[3]['id'],
 296         'srcName' => 'Mr. Minnie Mouse II',
 297         'dstID' => $this->contacts[2]['id'],
 298         'dstName' => 'Mr. Minnie Mouse II',
 299         'weight' => 20,
 300         'canMerge' => TRUE,
 301       ),
 302     ), $pairs);
 303   }
 304
 305   /**
 306    * Test function that gets organization pairs.
 307    *
 308    * Note the rule will match on organization_name OR email - hence lots of matches.
 309    */
 310   public function testGetOrganizationMatches() {
 311     $this->setupMatchData();
 312     $ruleGroups = $this->callAPISuccessGetSingle('RuleGroup', array('contact_type' => 'Organization', 'used' => 'Supervised'));
 313
 314     $pairs = CRM_Dedupe_Merger::getDuplicatePairs(
 315       $ruleGroups['id'],
 316       NULL,
 317       TRUE,
 318       25,
 319       FALSE
 320     );
 321
 322     $expectedPairs = array(
 323       0 => array(
 324         'srcID' => $this->contacts[5]['id'],
 325         'srcName' => 'Walt Disney Ltd',
 326         'dstID' => $this->contacts[4]['id'],
 327         'dstName' => 'Walt Disney Ltd',
 328         'weight' => 20,
 329         'canMerge' => TRUE,
 330       ),
 331       1 => array(
 332         'srcID' => $this->contacts[7]['id'],
 333         'srcName' => 'Walt Disney',
 334         'dstID' => $this->contacts[6]['id'],
 335         'dstName' => 'Walt Disney',
 336         'weight' => 10,
 337         'canMerge' => TRUE,
 338       ),
 339       2 => array(
 340         'srcID' => $this->contacts[6]['id'],
 341         'srcName' => 'Walt Disney',
 342         'dstID' => $this->contacts[4]['id'],
 343         'dstName' => 'Walt Disney Ltd',
 344         'weight' => 10,
 345         'canMerge' => TRUE,
 346       ),
 347       3 => array(
 348         'srcID' => $this->contacts[6]['id'],
 349         'srcName' => 'Walt Disney',
 350         'dstID' => $this->contacts[5]['id'],
 351         'dstName' => 'Walt Disney Ltd',
 352         'weight' => 10,
 353         'canMerge' => TRUE,
 354       ),
 355     );
 356     usort($pairs, array(__CLASS__, 'compareDupes'));
 357     usort($expectedPairs, array(__CLASS__, 'compareDupes'));
 358     $this->assertEquals($expectedPairs, $pairs);
 359   }
 360
 361   /**
 362    * Function to sort $duplicate records in a stable way.
 363    *
 364    * @param array $a
 365    * @param array $b
 366    * @return int
 367    */
 368   public static function compareDupes($a, $b) {
 369     foreach (array('srcName', 'dstName', 'srcID', 'dstID') as $field) {
 370       if ($a[$field] != $b[$field]) {
 371         return ($a[$field] < $b[$field]) ? 1 : -1;
 372       }
 373     }
 374     return 0;
 375   }
 376
 377   /**
 378    *  Test function that gets organization duplicate pairs.
 379    */
 380   public function testGetOrganizationMatchesInGroup() {
 381     $this->setupMatchData();
 382     $ruleGroups = $this->callAPISuccessGetSingle('RuleGroup', array('contact_type' => 'Organization', 'used' => 'Supervised'));
 383
 384     $groupID = $this->groupCreate(array('title' => 'she-mice'));
 385
 386     $this->callAPISuccess('GroupContact', 'create', array('group_id' => $groupID, 'contact_id' => $this->contacts[4]['id']));
 387
 388     $pairs = CRM_Dedupe_Merger::getDuplicatePairs(
 389       $ruleGroups['id'],
 390       $groupID,
 391       TRUE,
 392       25,
 393       FALSE
 394     );
 395
 396     $this->assertEquals(array(
 397       0 => array(
 398         'srcID' => $this->contacts[5]['id'],
 399         'srcName' => 'Walt Disney Ltd',
 400         'dstID' => $this->contacts[4]['id'],
 401         'dstName' => 'Walt Disney Ltd',
 402         'weight' => 20,
 403         'canMerge' => TRUE,
 404       ),
 405       1 => array(
 406         'srcID' => $this->contacts[6]['id'],
 407         'srcName' => 'Walt Disney',
 408         'dstID' => $this->contacts[4]['id'],
 409         'dstName' => 'Walt Disney Ltd',
 410         'weight' => 10,
 411         'canMerge' => TRUE,
 412       ),
 413     ), $pairs);
 414   }
 415
 416   /**
 417    * Test function that gets duplicate pairs.
 418    *
 419    * It turns out there are 2 code paths retrieving this data so my initial focus is on ensuring
 420    * they match.
 421    */
 422   public function testGetMatchesInGroup() {
 423     $this->setupMatchData();
 424
 425     $groupID = $this->groupCreate(array('title' => 'she-mice'));
 426
 427     $this->callAPISuccess('GroupContact', 'create', array('group_id' => $groupID, 'contact_id' => $this->contacts[3]['id']));
 428
 429     $pairs = CRM_Dedupe_Merger::getDuplicatePairs(
 430       1,
 431       $groupID,
 432       TRUE,
 433       25,
 434       FALSE
 435     );
 436
 437     $this->assertEquals(array(
 438       0 => array(
 439         'srcID' => $this->contacts[3]['id'],
 440         'srcName' => 'Mr. Minnie Mouse II',
 441         'dstID' => $this->contacts[2]['id'],
 442         'dstName' => 'Mr. Minnie Mouse II',
 443         'weight' => 20,
 444         'canMerge' => TRUE,
 445       ),
 446     ), $pairs);
 447   }
 448
 449   /**
 450    * Set up some contacts for our matching.
 451    */
 452   public function setupMatchData() {
 453     $fixtures = array(
 454       array(
 455         'first_name' => 'Mickey',
 456         'last_name' => 'Mouse',
 457         'email' => 'mickey@mouse.com',
 458       ),
 459       array(
 460         'first_name' => 'Mickey',
 461         'last_name' => 'Mouse',
 462         'email' => 'mickey@mouse.com',
 463       ),
 464       array(
 465         'first_name' => 'Minnie',
 466         'last_name' => 'Mouse',
 467         'email' => 'mickey@mouse.com',
 468       ),
 469       array(
 470         'first_name' => 'Minnie',
 471         'last_name' => 'Mouse',
 472         'email' => 'mickey@mouse.com',
 473       ),
 474     );
 475     foreach ($fixtures as $fixture) {
 476       $contactID = $this->individualCreate($fixture);
 477       $this->contacts[] = array_merge($fixture, array('id' => $contactID));
 478     }
 479     $organizationFixtures = array(
 480       array(
 481         'organization_name' => 'Walt Disney Ltd',
 482         'email' => 'walt@disney.com',
 483       ),
 484       array(
 485         'organization_name' => 'Walt Disney Ltd',
 486         'email' => 'walt@disney.com',
 487       ),
 488       array(
 489         'organization_name' => 'Walt Disney',
 490         'email' => 'walt@disney.com',
 491       ),
 492       array(
 493         'organization_name' => 'Walt Disney',
 494         'email' => 'walter@disney.com',
 495       ),
 496     );
 497     foreach ($organizationFixtures as $fixture) {
 498       $contactID = $this->organizationCreate($fixture);
 499       $this->contacts[] = array_merge($fixture, array('id' => $contactID));
 500     }
 501   }
 502
 503
 504   /**
 505    * Get the list of tables that refer to the CID.
 506    *
 507    * This is a statically maintained (in this test list).
 508    *
 509    * There is also a check against an automated list but having both seems to add extra stability to me. They do
 510    * not change often.
 511    */
 512   public function getStaticCIDRefs() {
 513     return array(
 514       'civicrm_acl_cache' => array(
 515         0 => 'contact_id',
 516       ),
 517       'civicrm_acl_contact_cache' => array(
 518         0 => 'user_id',
 519         1 => 'contact_id',
 520       ),
 521       'civicrm_action_log' => array(
 522         0 => 'contact_id',
 523       ),
 524       'civicrm_activity_contact' => array(
 525         0 => 'contact_id',
 526       ),
 527       'civicrm_address' => array(
 528         0 => 'contact_id',
 529       ),
 530       'civicrm_batch' => array(
 531         0 => 'created_id',
 532         1 => 'modified_id',
 533       ),
 534       'civicrm_campaign' => array(
 535         0 => 'created_id',
 536         1 => 'last_modified_id',
 537       ),
 538       'civicrm_case_contact' => array(
 539         0 => 'contact_id',
 540       ),
 541       'civicrm_contact' => array(
 542         0 => 'primary_contact_id',
 543         1 => 'employer_id',
 544       ),
 545       'civicrm_contribution' => array(
 546         0 => 'contact_id',
 547       ),
 548       'civicrm_contribution_page' => array(
 549         0 => 'created_id',
 550       ),
 551       'civicrm_contribution_recur' => array(
 552         0 => 'contact_id',
 553       ),
 554       'civicrm_contribution_soft' => array(
 555         0 => 'contact_id',
 556       ),
 557       'civicrm_custom_group' => array(
 558         0 => 'created_id',
 559       ),
 560       'civicrm_dashboard_contact' => array(
 561         0 => 'contact_id',
 562       ),
 563       'civicrm_dedupe_exception' => array(
 564         0 => 'contact_id1',
 565         1 => 'contact_id2',
 566       ),
 567       'civicrm_domain' => array(
 568         0 => 'contact_id',
 569       ),
 570       'civicrm_email' => array(
 571         0 => 'contact_id',
 572       ),
 573       'civicrm_event' => array(
 574         0 => 'created_id',
 575       ),
 576       'civicrm_event_carts' => array(
 577         0 => 'user_id',
 578       ),
 579       'civicrm_financial_account' => array(
 580         0 => 'contact_id',
 581       ),
 582       'civicrm_financial_item' => array(
 583         0 => 'contact_id',
 584       ),
 585       'civicrm_grant' => array(
 586         0 => 'contact_id',
 587       ),
 588       'civicrm_group' => array(
 589         0 => 'created_id',
 590         1 => 'modified_id',
 591       ),
 592       'civicrm_group_contact' => array(
 593         0 => 'contact_id',
 594       ),
 595       'civicrm_group_contact_cache' => array(
 596         0 => 'contact_id',
 597       ),
 598       'civicrm_group_organization' => array(
 599         0 => 'organization_id',
 600       ),
 601       'civicrm_im' => array(
 602         0 => 'contact_id',
 603       ),
 604       'civicrm_log' => array(
 605         0 => 'modified_id',
 606       ),
 607       'civicrm_mailing' => array(
 608         0 => 'created_id',
 609         1 => 'scheduled_id',
 610         2 => 'approver_id',
 611       ),
 612       'civicrm_mailing_abtest' => array(
 613         0 => 'created_id',
 614       ),
 615       'civicrm_mailing_event_queue' => array(
 616         0 => 'contact_id',
 617       ),
 618       'civicrm_mailing_event_subscribe' => array(
 619         0 => 'contact_id',
 620       ),
 621       'civicrm_mailing_recipients' => array(
 622         0 => 'contact_id',
 623       ),
 624       'civicrm_membership' => array(
 625         0 => 'contact_id',
 626       ),
 627       'civicrm_membership_log' => array(
 628         0 => 'modified_id',
 629       ),
 630       'civicrm_membership_type' => array(
 631         0 => 'member_of_contact_id',
 632       ),
 633       'civicrm_note' => array(
 634         0 => 'contact_id',
 635       ),
 636       'civicrm_openid' => array(
 637         0 => 'contact_id',
 638       ),
 639       'civicrm_participant' => array(
 640         0 => 'contact_id',
 641         1 => 'transferred_to_contact_id', //CRM-16761
 642       ),
 643       'civicrm_payment_token' => array(
 644         0 => 'contact_id',
 645         1 => 'created_id',
 646       ),
 647       'civicrm_pcp' => array(
 648         0 => 'contact_id',
 649       ),
 650       'civicrm_phone' => array(
 651         0 => 'contact_id',
 652       ),
 653       'civicrm_pledge' => array(
 654         0 => 'contact_id',
 655       ),
 656       'civicrm_print_label' => array(
 657         0 => 'created_id',
 658       ),
 659       'civicrm_relationship' => array(
 660         0 => 'contact_id_a',
 661         1 => 'contact_id_b',
 662       ),
 663       'civicrm_report_instance' => array(
 664         0 => 'created_id',
 665         1 => 'owner_id',
 666       ),
 667       'civicrm_setting' => array(
 668         0 => 'contact_id',
 669         1 => 'created_id',
 670       ),
 671       'civicrm_subscription_history' => array(
 672         0 => 'contact_id',
 673       ),
 674       'civicrm_survey' => array(
 675         0 => 'created_id',
 676         1 => 'last_modified_id',
 677       ),
 678       'civicrm_tag' => array(
 679         0 => 'created_id',
 680       ),
 681       'civicrm_uf_group' => array(
 682         0 => 'created_id',
 683       ),
 684       'civicrm_uf_match' => array(
 685         0 => 'contact_id',
 686       ),
 687       'civicrm_value_testgetcidref_1' => array(
 688         0 => 'entity_id',
 689       ),
 690       'civicrm_website' => array(
 691         0 => 'contact_id',
 692       ),
 693     );
 694   }
 695
 696   /**
 697    * Get a list of CIDs that is calculated off the schema.
 698    *
 699    * Note this is an expensive and table locking query. Should be safe in tests though.
 700    */
 701   public function getCalculatedCIDRefs() {
 702     $cidRefs = array();
 703     $sql = "
 704 SELECT
 705     table_name,
 706     column_name
 707 FROM information_schema.key_column_usage
 708 WHERE
 709     referenced_table_schema = database() AND
 710     referenced_table_name = 'civicrm_contact' AND
 711     referenced_column_name = 'id';
 712       ";
 713     $dao = CRM_Core_DAO::executeQuery($sql);
 714     while ($dao->fetch()) {
 715       $cidRefs[$dao->table_name][] = $dao->column_name;
 716     }
 717     // Do specific re-ordering changes to make this the same as the ref validated one.
 718     // The above query orders by FK alphabetically.
 719     // There might be cleverer ways to do this but it shouldn't change much.
 720     $cidRefs['civicrm_contact'][0] = 'primary_contact_id';
 721     $cidRefs['civicrm_contact'][1] = 'employer_id';
 722     $cidRefs['civicrm_acl_contact_cache'][0] = 'user_id';
 723     $cidRefs['civicrm_acl_contact_cache'][1] = 'contact_id';
 724     $cidRefs['civicrm_mailing'][0] = 'created_id';
 725     $cidRefs['civicrm_mailing'][1] = 'scheduled_id';
 726     $cidRefs['civicrm_mailing'][2] = 'approver_id';
 727     return $cidRefs;
 728   }
 729
 730 }