tests/phpunit/CRM/Activity/BAO/ActivityTest.php

   1 <?php
   2
   3 /**
   4  * Class CRM_Activity_BAO_ActivityTest
   5  * @group headless
   6  */
   7 class CRM_Activity_BAO_ActivityTest extends CiviUnitTestCase {
   8   public function setUp() {
   9     parent::setUp();
  10     $this->prepareForACLs();
  11     CRM_Core_Config::singleton()->userPermissionClass->permissions = array('view all contacts', 'access CiviCRM');
  12   }
  13
  14   /**
  15    * Clean up after tests.
  16    */
  17   public function tearDown() {
  18     $tablesToTruncate = array('civicrm_activity', 'civicrm_activity_contact');
  19     $this->quickCleanup($tablesToTruncate);
  20     $this->cleanUpAfterACLs();
  21     parent::tearDown();
  22   }
  23
  24   /**
  25    * Test case for create() method.
  26    */
  27   public function testCreate() {
  28     $contactId = $this->individualCreate();
  29
  30     $params = array(
  31       'source_contact_id' => $contactId,
  32       'subject' => 'Scheduling Meeting',
  33       'activity_type_id' => 2,
  34     );
  35
  36     CRM_Activity_BAO_Activity::create($params);
  37
  38     $activityId = $this->assertDBNotNull('CRM_Activity_DAO_Activity', 'Scheduling Meeting', 'id',
  39       'subject', 'Database check for created activity.'
  40     );
  41
  42     // Now call create() to modify an existing Activity.
  43     $params = array(
  44       'id' => $activityId,
  45       'source_contact_id' => $contactId,
  46       'subject' => 'Scheduling Interview',
  47       'activity_type_id' => 3,
  48     );
  49
  50     CRM_Activity_BAO_Activity::create($params);
  51
  52     $activityTypeId = $this->assertDBNotNull('CRM_Activity_DAO_Activity', 'Scheduling Interview',
  53       'activity_type_id',
  54       'subject', 'Database check on updated activity record.'
  55     );
  56     $this->assertEquals($activityTypeId, 3, 'Verify activity type id is 3.');
  57
  58     $this->contactDelete($contactId);
  59   }
  60
  61   /**
  62    * Test case for getContactActivity() method.
  63    *
  64    * getContactActivity() method get activities detail for given target contact id.
  65    */
  66   public function testGetContactActivity() {
  67     $contactId = $this->individualCreate();
  68     $params = array(
  69       'first_name' => 'liz',
  70       'last_name' => 'hurleey',
  71     );
  72     $targetContactId = $this->individualCreate($params);
  73
  74     $params = array(
  75       'source_contact_id' => $contactId,
  76       'subject' => 'Scheduling Meeting',
  77       'activity_type_id' => 2,
  78       'target_contact_id' => array($targetContactId),
  79       'activity_date_time' => date('Ymd'),
  80     );
  81
  82     $this->callAPISuccess('Activity', 'create', $params);
  83
  84     $activityId = $this->assertDBNotNull('CRM_Activity_DAO_Activity', 'Scheduling Meeting',
  85       'id',
  86       'subject', 'Database check for created activity.'
  87     );
  88
  89     // @todo - remove this deprecated functions
  90     $activities = CRM_Activity_BAO_Activity::getContactActivity($targetContactId);
  91
  92     $this->assertEquals($activities[$activityId]['subject'], 'Scheduling Meeting', 'Verify activity subject is correct.');
  93
  94     $this->contactDelete($contactId);
  95     $this->contactDelete($targetContactId);
  96   }
  97
  98   /**
  99    * Test case for retrieve() method.
 100    *
 101    * Retrieve($params, $defaults) method return activity detail for given params
 102    *                              and set defaults.
 103    */
 104   public function testRetrieve() {
 105     $contactId = $this->individualCreate();
 106     $params = array(
 107       'first_name' => 'liz',
 108       'last_name' => 'hurleey',
 109     );
 110     $targetContactId = $this->individualCreate($params);
 111
 112     $params = array(
 113       'source_contact_id' => $contactId,
 114       'subject' => 'Scheduling Meeting',
 115       'activity_type_id' => 2,
 116       'target_contact_id' => array($targetContactId),
 117       'activity_date_time' => date('Ymd'),
 118     );
 119
 120     CRM_Activity_BAO_Activity::create($params);
 121
 122     $this->assertDBNotNull('CRM_Activity_DAO_Activity', 'Scheduling Meeting', 'id',
 123       'subject', 'Database check for created activity.'
 124     );
 125
 126     $this->assertDBNotNull('CRM_Activity_DAO_ActivityContact', $targetContactId,
 127       'id', 'contact_id',
 128       'Database check for created activity target.'
 129     );
 130
 131     $defaults = array();
 132     $activity = CRM_Activity_BAO_Activity::retrieve($params, $defaults);
 133
 134     $this->assertEquals($activity->subject, 'Scheduling Meeting', 'Verify activity subject is correct.');
 135     $this->assertEquals($activity->activity_type_id, 2, 'Verify activity type id is correct.');
 136     $this->assertEquals($defaults['source_contact_id'], $contactId, 'Verify source contact id is correct.');
 137
 138     $this->assertEquals($defaults['subject'], 'Scheduling Meeting', 'Verify activity subject is correct.');
 139     $this->assertEquals($defaults['activity_type_id'], 2, 'Verify activity type id is correct.');
 140
 141     $this->assertEquals($defaults['target_contact'][0], $targetContactId, 'Verify target contact id is correct.');
 142
 143     $this->contactDelete($contactId);
 144     $this->contactDelete($targetContactId);
 145   }
 146
 147   /**
 148    * Test case for deleteActivity() method.
 149    *
 150    * deleteActivity($params) method deletes activity for given params.
 151    */
 152   public function testDeleteActivity() {
 153     $contactId = $this->individualCreate();
 154     $params = array(
 155       'first_name' => 'liz',
 156       'last_name' => 'hurleey',
 157     );
 158     $targetContactId = $this->individualCreate($params);
 159
 160     $params = array(
 161       'source_contact_id' => $contactId,
 162       'source_record_id' => $contactId,
 163       'subject' => 'Scheduling Meeting',
 164       'activity_type_id' => 2,
 165       'target_contact_id' => array($targetContactId),
 166       'activity_date_time' => date('Ymd'),
 167     );
 168
 169     CRM_Activity_BAO_Activity::create($params);
 170
 171     $this->assertDBNotNull('CRM_Activity_DAO_Activity', 'Scheduling Meeting', 'id',
 172       'subject', 'Database check for created activity.'
 173     );
 174
 175     $this->assertDBNotNull('CRM_Activity_DAO_ActivityContact', $targetContactId,
 176       'id', 'contact_id',
 177       'Database check for created activity target.'
 178     );
 179     $params = array(
 180       'source_contact_id' => $contactId,
 181       'source_record_id' => $contactId,
 182       'subject' => 'Scheduling Meeting',
 183       'activity_type_id' => 2,
 184     );
 185
 186     CRM_Activity_BAO_Activity::deleteActivity($params);
 187
 188     $this->assertDBNull('CRM_Activity_DAO_Activity', 'Scheduling Meeting', 'id',
 189       'subject', 'Database check for deleted activity.'
 190     );
 191     $this->contactDelete($contactId);
 192     $this->contactDelete($targetContactId);
 193   }
 194
 195   /**
 196    * Test case for deleteActivityTarget() method.
 197    *
 198    * deleteActivityTarget($activityId) method deletes activity target for given activity id.
 199    */
 200   public function testDeleteActivityTarget() {
 201     $contactId = $this->individualCreate();
 202     $params = array(
 203       'first_name' => 'liz',
 204       'last_name' => 'hurleey',
 205     );
 206     $targetContactId = $this->individualCreate($params);
 207
 208     $params = array(
 209       'source_contact_id' => $contactId,
 210       'subject' => 'Scheduling Meeting',
 211       'activity_type_id' => 2,
 212       'target_contact_id' => array($targetContactId),
 213       'activity_date_time' => date('Ymd'),
 214     );
 215
 216     CRM_Activity_BAO_Activity::create($params);
 217
 218     $activityId = $this->assertDBNotNull('CRM_Activity_DAO_Activity', 'Scheduling Meeting', 'id',
 219       'subject', 'Database check for created activity.'
 220     );
 221
 222     $this->assertDBNotNull('CRM_Activity_DAO_ActivityContact', $targetContactId,
 223       'id', 'contact_id',
 224       'Database check for created activity target.'
 225     );
 226
 227     CRM_Activity_BAO_Activity::deleteActivityContact($activityId, 3);
 228
 229     $this->assertDBNull('CRM_Activity_DAO_ActivityContact', $targetContactId, 'id',
 230       'contact_id', 'Database check for deleted activity target.'
 231     );
 232
 233     $this->contactDelete($contactId);
 234     $this->contactDelete($targetContactId);
 235   }
 236
 237   /**
 238    * Test case for deleteActivityAssignment() method.
 239    *
 240    * deleteActivityAssignment($activityId) method deletes activity assignment for given activity id.
 241    */
 242   public function testDeleteActivityAssignment() {
 243     $contactId = $this->individualCreate();
 244     $params = array(
 245       'first_name' => 'liz',
 246       'last_name' => 'hurleey',
 247     );
 248     $assigneeContactId = $this->individualCreate($params);
 249
 250     $params = array(
 251       'source_contact_id' => $contactId,
 252       'subject' => 'Scheduling Meeting',
 253       'activity_type_id' => 2,
 254       'assignee_contact_id' => array($assigneeContactId),
 255       'activity_date_time' => date('Ymd'),
 256     );
 257
 258     CRM_Activity_BAO_Activity::create($params);
 259
 260     $activityId = $this->assertDBNotNull('CRM_Activity_DAO_Activity', 'Scheduling Meeting', 'id',
 261       'subject', 'Database check for created activity.'
 262     );
 263
 264     $this->assertDBNotNull('CRM_Activity_DAO_ActivityContact',
 265       $assigneeContactId, 'id', 'contact_id',
 266       'Database check for created activity assignment.'
 267     );
 268
 269     CRM_Activity_BAO_Activity::deleteActivityContact($activityId, 1);
 270
 271     $this->assertDBNull('CRM_Activity_DAO_ActivityContact', $assigneeContactId, 'id',
 272       'contact_id', 'Database check for deleted activity assignment.'
 273     );
 274
 275     $this->contactDelete($contactId);
 276     $this->contactDelete($assigneeContactId);
 277   }
 278
 279   /**
 280    * Test getActivities BAO method for getting count.
 281    */
 282   public function testGetActivitiesCountForAdminDashboard() {
 283     $this->setUpForActivityDashboardTests();
 284     $activityCount = CRM_Activity_BAO_Activity::getActivities($this->_params, TRUE);
 285     $this->assertEquals(8, $activityCount);
 286   }
 287
 288   /**
 289    * Test getActivities BAO method for getting count
 290    */
 291   public function testGetActivitiesCountforNonAdminDashboard() {
 292     $op = new PHPUnit_Extensions_Database_Operation_Insert();
 293     $op->execute($this->_dbconn,
 294       $this->createFlatXMLDataSet(
 295         dirname(__FILE__) . '/activities_for_dashboard_count.xml'
 296       )
 297     );
 298
 299     $params = array(
 300       'contact_id' => 9,
 301       'admin' => FALSE,
 302       'caseId' => NULL,
 303       'context' => 'home',
 304       'activity_type_id' => NULL,
 305       'offset' => 0,
 306       'rowCount' => 0,
 307       'sort' => NULL,
 308     );
 309
 310     $activityCount = CRM_Activity_BAO_Activity::getActivities($params, TRUE);
 311
 312     //since we are loading activities from dataset, we know total number of activities for this contact
 313     // 5 activities ( 2 scheduled, 3 Completed ), note that dashboard shows only scheduled activities
 314     $count = 2;
 315     $this->assertEquals($count, $activityCount);
 316   }
 317
 318   /**
 319    * Test getActivities BAO method for getting count
 320    */
 321   public function testGetActivitiesCountforContactSummary() {
 322     $op = new PHPUnit_Extensions_Database_Operation_Insert();
 323     $op->execute($this->_dbconn,
 324       $this->createFlatXMLDataSet(
 325         dirname(__FILE__) . '/activities_for_dashboard_count.xml'
 326       )
 327     );
 328
 329     $params = array(
 330       'contact_id' => 9,
 331       'admin' => FALSE,
 332       'caseId' => NULL,
 333       'context' => 'activity',
 334       'activity_type_id' => NULL,
 335       'offset' => 0,
 336       'rowCount' => 0,
 337       'sort' => NULL,
 338     );
 339     $activityCount = CRM_Activity_BAO_Activity::getActivities($params, TRUE);
 340
 341     //since we are loading activities from dataset, we know total number of activities for this contact
 342     // 5 activities, Contact Summary should show all activities
 343     $count = 5;
 344     $this->assertEquals($count, $activityCount);
 345   }
 346
 347   /**
 348    * CRM-18706 - Test Include/Exclude Activity Filters
 349    */
 350   public function testActivityFilters() {
 351     $op = new PHPUnit_Extensions_Database_Operation_Insert();
 352     $op->execute($this->_dbconn,
 353       $this->createFlatXMLDataSet(
 354         dirname(__FILE__) . '/activities_for_dashboard_count.xml'
 355       )
 356     );
 357
 358     global $_GET;
 359     $_GET = array(
 360       'cid' => 9,
 361       'context' => 'activity',
 362       'activity_type_id' => 1,
 363       'is_unit_test' => 1,
 364     );
 365     $obj = new CRM_Activity_Page_AJAX();
 366
 367     $activities = $obj->getContactActivity();
 368     // This should include activities of type Meeting only.
 369     foreach ($activities['data'] as $value) {
 370       $this->assertContains('Meeting', $value['activity_type']);
 371     }
 372     unset($_GET['activity_type_id']);
 373
 374     $_GET['activity_type_exclude_id'] = 1;
 375     $activities = $obj->getContactActivity();
 376     // None of the activities should be of type Meeting.
 377     foreach ($activities['data'] as $value) {
 378       $this->assertNotEquals('Meeting', $value['activity_type']);
 379     }
 380   }
 381
 382   /**
 383    * Test getActivities BAO method for getting count
 384    */
 385   public function testGetActivitiesCountforContactSummaryWithNoActivities() {
 386     $op = new PHPUnit_Extensions_Database_Operation_Insert();
 387     $op->execute($this->_dbconn,
 388       $this->createFlatXMLDataSet(
 389         dirname(__FILE__) . '/activities_for_dashboard_count.xml'
 390       )
 391     );
 392
 393     $params = array(
 394       'contact_id' => 17,
 395       'admin' => FALSE,
 396       'caseId' => NULL,
 397       'context' => 'home',
 398       'activity_type_id' => NULL,
 399       'offset' => 0,
 400       'rowCount' => 0,
 401       'sort' => NULL,
 402     );
 403     $activityCount = CRM_Activity_BAO_Activity::getActivities($params, TRUE);
 404
 405     //since we are loading activities from dataset, we know total number of activities for this contact
 406     // this contact does not have any activity
 407     $this->assertEquals(0, $activityCount);
 408   }
 409
 410   /**
 411    * Test getActivities BAO method.
 412    */
 413   public function testGetActivitiesForAdminDashboard() {
 414     $this->setUpForActivityDashboardTests();
 415     $activities = CRM_Activity_BAO_Activity::getActivities($this->_params);
 416
 417     //since we are loading activities from dataset, we know total number of activities
 418     // with no contact ID and there should be 8 schedule activities shown on dashboard
 419     $count = 8;
 420     $this->assertEquals($count, count($activities));
 421
 422     foreach ($activities as $key => $value) {
 423       $this->assertEquals($value['subject'], "subject {$key}", 'Verify activity subject is correct.');
 424       $this->assertEquals($value['activity_type_id'], 2, 'Verify activity type is correct.');
 425       $this->assertEquals($value['status_id'], 1, 'Verify all activities are scheduled.');
 426     }
 427   }
 428
 429   /**
 430    * Test getActivities BAO method.
 431    */
 432   public function testGetActivitiesForAdminDashboardNoViewContacts() {
 433     CRM_Core_Config::singleton()->userPermissionClass->permissions = array('access CiviCRM');
 434     $this->setUpForActivityDashboardTests();
 435     $activities = CRM_Activity_BAO_Activity::getActivities($this->_params);
 436     $this->assertEquals(0, count($activities));
 437   }
 438
 439   /**
 440    * Test getActivities BAO method.
 441    */
 442   public function testGetActivitiesForAdminDashboardAclLimitedViewContacts() {
 443     CRM_Core_Config::singleton()->userPermissionClass->permissions = array('access CiviCRM');
 444     $this->allowedContacts = array(1, 3, 4, 5);
 445     $this->hookClass->setHook('civicrm_aclWhereClause', array($this, 'aclWhereMultipleContacts'));
 446     $this->setUpForActivityDashboardTests();
 447     $activities = CRM_Activity_BAO_Activity::getActivities($this->_params);
 448     $this->assertEquals(1, count($activities));
 449
 450   }
 451
 452   /**
 453    * Test getActivities BAO method.
 454    */
 455   public function testGetActivitiesforNonAdminDashboard() {
 456     $op = new PHPUnit_Extensions_Database_Operation_Insert();
 457     $op->execute($this->_dbconn,
 458       $this->createFlatXMLDataSet(
 459         dirname(__FILE__) . '/activities_for_dashboard_count.xml'
 460       )
 461     );
 462
 463     $contactID = 9;
 464     $params = array(
 465       'contact_id' => $contactID,
 466       'admin' => FALSE,
 467       'caseId' => NULL,
 468       'context' => 'home',
 469       'activity_type_id' => NULL,
 470       'offset' => 0,
 471       'rowCount' => 0,
 472       'sort' => NULL,
 473     );
 474     $activities = CRM_Activity_BAO_Activity::getActivities($params);
 475
 476     //since we are loading activities from dataset, we know total number of activities for this contact
 477     // 5 activities ( 2 scheduled, 3 Completed ), note that dashboard shows only scheduled activities
 478     $count = 2;
 479     $this->assertEquals($count, count($activities));
 480
 481     foreach ($activities as $key => $value) {
 482       $this->assertEquals($value['subject'], "subject {$key}", 'Verify activity subject is correct.');
 483       $this->assertEquals($value['activity_type_id'], 2, 'Verify activity type is correct.');
 484       $this->assertEquals($value['status_id'], 1, 'Verify all activities are scheduled.');
 485
 486       if ($key == 3) {
 487         $this->assertArrayHasKey($contactID, $value['target_contact_name']);
 488       }
 489       elseif ($key == 4) {
 490         $this->assertArrayHasKey($contactID, $value['assignee_contact_name']);
 491       }
 492     }
 493   }
 494
 495   /**
 496    * Test target contact count.
 497    */
 498   public function testTargetCountforContactSummary() {
 499     $targetCount = 5;
 500     $contactId = $this->individualCreate();
 501     $targetContactIDs = array();
 502     for ($i = 0; $i < $targetCount; $i++) {
 503       $targetContactIDs[] = $this->individualCreate(array(), $i);
 504     }
 505     // Create activities with 5 target contacts.
 506     $activityParams = array(
 507       'source_contact_id' => $contactId,
 508       'target_contact_id' => $targetContactIDs,
 509     );
 510     $this->activityCreate($activityParams);
 511
 512     $params = array(
 513       'contact_id' => $contactId,
 514       'context' => 'activity',
 515     );
 516     $activities = CRM_Activity_BAO_Activity::getActivities($params);
 517
 518     //verify target count
 519     $this->assertEquals($targetCount, $activities[1]['target_contact_counter']);
 520   }
 521
 522   /**
 523    * Test getActivities BAO method.
 524    */
 525   public function testGetActivitiesforContactSummary() {
 526     $op = new PHPUnit_Extensions_Database_Operation_Insert();
 527     $op->execute($this->_dbconn,
 528       $this->createFlatXMLDataSet(
 529         dirname(__FILE__) . '/activities_for_dashboard_count.xml'
 530       )
 531     );
 532
 533     $contactID = 9;
 534     $params = array(
 535       'contact_id' => $contactID,
 536       'admin' => FALSE,
 537       'caseId' => NULL,
 538       'context' => 'activity',
 539       'activity_type_id' => NULL,
 540       'offset' => 0,
 541       'rowCount' => 0,
 542       'sort' => NULL,
 543     );
 544     $activities = CRM_Activity_BAO_Activity::getActivities($params);
 545
 546     //since we are loading activities from dataset, we know total number of activities for this contact
 547     // 5 activities, Contact Summary should show all activities
 548     $count = 5;
 549     $this->assertEquals($count, count($activities));
 550
 551     foreach ($activities as $key => $value) {
 552       $this->assertEquals($value['subject'], "subject {$key}", 'Verify activity subject is correct.');
 553
 554       if ($key > 8) {
 555         $this->assertEquals($value['status_id'], 2, 'Verify all activities are scheduled.');
 556       }
 557       else {
 558         $this->assertEquals($value['status_id'], 1, 'Verify all activities are scheduled.');
 559       }
 560
 561       if ($key > 8) {
 562         $this->assertEquals($value['activity_type_id'], 1, 'Verify activity type is correct.');
 563       }
 564       else {
 565         $this->assertEquals($value['activity_type_id'], 2, 'Verify activity type is correct.');
 566       }
 567
 568       if ($key == 3) {
 569         $this->assertArrayHasKey($contactID, $value['target_contact_name']);
 570       }
 571       elseif ($key == 4) {
 572         $this->assertArrayHasKey($contactID, $value['assignee_contact_name']);
 573       }
 574     }
 575   }
 576
 577   /**
 578    * Test getActivities BAO method.
 579    */
 580   public function testGetActivitiesforContactSummaryWithActivities() {
 581     $op = new PHPUnit_Extensions_Database_Operation_Insert();
 582     $op->execute($this->_dbconn,
 583       $this->createFlatXMLDataSet(
 584         dirname(__FILE__) . '/activities_for_dashboard_count.xml'
 585       )
 586     );
 587
 588     // parameters for different test casess, check each array key for the specific test-case
 589     $testCases = array(
 590       'with-no-activity' => array(
 591         'params' => array(
 592           'contact_id' => 17,
 593           'admin' => FALSE,
 594           'caseId' => NULL,
 595           'context' => 'home',
 596           'activity_type_id' => NULL,
 597           'offset' => 0,
 598           'rowCount' => 0,
 599           'sort' => NULL,
 600         ),
 601       ),
 602       'with-activity' => array(
 603         'params' => array(
 604           'contact_id' => 1,
 605           'admin' => FALSE,
 606           'caseId' => NULL,
 607           'context' => 'home',
 608           'activity_type_id' => NULL,
 609           'offset' => 0,
 610           'rowCount' => 0,
 611           'sort' => NULL,
 612         ),
 613       ),
 614       'with-activity_type' => array(
 615         'params' => array(
 616           'contact_id' => 3,
 617           'admin' => FALSE,
 618           'caseId' => NULL,
 619           'context' => 'home',
 620           'activity_type_id' => 2,
 621           'offset' => 0,
 622           'rowCount' => 0,
 623           'sort' => NULL,
 624         ),
 625       ),
 626       'exclude-all-activity_type' => array(
 627         'params' => array(
 628           'contact_id' => 3,
 629           'admin' => FALSE,
 630           'caseId' => NULL,
 631           'context' => 'home',
 632           'activity_type_exclude_id' => array(1, 2),
 633           'offset' => 0,
 634           'rowCount' => 0,
 635           'sort' => NULL,
 636         ),
 637       ),
 638       'sort-by-subject' => array(
 639         'params' => array(
 640           'contact_id' => 1,
 641           'admin' => FALSE,
 642           'caseId' => NULL,
 643           'context' => 'home',
 644           'activity_type_id' => NULL,
 645           'offset' => 0,
 646           'rowCount' => 0,
 647           'sort' => 'subject DESC',
 648         ),
 649       ),
 650     );
 651
 652     foreach ($testCases as $caseName => $testCase) {
 653       $activities = CRM_Activity_BAO_Activity::getActivities($testCase['params']);
 654       $activityCount = CRM_Activity_BAO_Activity::getActivities($testCase['params'], TRUE);
 655       if ($caseName == 'with-no-activity') {
 656         $this->assertEquals(0, count($activities));
 657         $this->assertEquals(0, $activityCount);
 658       }
 659       elseif ($caseName == 'with-activity') {
 660         // contact id 1 is assigned as source, target and assignee for activity id 1, 7 and 8 respectively
 661         $this->assertEquals(3, count($activities));
 662         $this->assertEquals(3, $activityCount);
 663         $this->assertEquals(1, $activities[1]['source_contact_id']);
 664         $this->assertEquals(TRUE, array_key_exists(1, $activities[7]['target_contact_name']));
 665         $this->assertEquals(TRUE, array_key_exists(1, $activities[8]['assignee_contact_name']));
 666       }
 667       elseif ($caseName == 'with-activity_type') {
 668         // contact id 3 for activity type 2 is assigned as assignee, source and target for
 669         // activity id 1, 3 and 8 respectively
 670         $this->assertEquals(3, count($activities));
 671         $this->assertEquals(3, $activityCount);
 672         // ensure activity type id is 2
 673         $this->assertEquals(2, $activities[1]['activity_type_id']);
 674         $this->assertEquals(3, $activities[3]['source_contact_id']);
 675         $this->assertEquals(TRUE, array_key_exists(3, $activities[8]['target_contact_name']));
 676         $this->assertEquals(TRUE, array_key_exists(3, $activities[1]['assignee_contact_name']));
 677       }
 678       if ($caseName == 'exclude-all-activity_type') {
 679         $this->assertEquals(0, count($activities));
 680         $this->assertEquals(0, $activityCount);
 681       }
 682       if ($caseName == 'sort-by-subject') {
 683         $this->assertEquals(3, count($activities));
 684         $this->assertEquals(3, $activityCount);
 685         // activities should be order by 'subject DESC'
 686         $subjectOrder = array(
 687           'subject 8',
 688           'subject 7',
 689           'subject 1',
 690         );
 691         $count = 0;
 692         foreach ($activities as $activity) {
 693           $this->assertEquals($subjectOrder[$count], $activity['subject']);
 694           $count++;
 695         }
 696       }
 697     }
 698   }
 699
 700   /**
 701    * CRM-20308: Test from email address when a 'copy of Activity' event occur
 702    */
 703   public function testEmailAddressOfActivityCopy() {
 704     // Case 1: assert the 'From' Email Address of source Actvity Contact ID
 705     // create activity with source contact ID which has email address
 706     $assigneeContactId = $this->individualCreate();
 707     $sourceContactParams = array(
 708       'first_name' => 'liz',
 709       'last_name' => 'hurleey',
 710       'email' => substr(sha1(rand()), 0, 7) . '@testemail.com',
 711     );
 712     $sourceContactID = $this->individualCreate($sourceContactParams);
 713     $sourceDisplayName = CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Contact', $sourceContactID, 'display_name');
 714
 715     // create an activity using API
 716     $params = array(
 717       'source_contact_id' => $sourceContactID,
 718       'subject' => 'Scheduling Meeting ' . substr(sha1(rand()), 0, 4),
 719       'activity_type_id' => CRM_Core_PseudoConstant::getKey('CRM_Activity_BAO_Activity', 'activity_type_id', 'Meeting'),
 720       'assignee_contact_id' => array($assigneeContactId),
 721       'activity_date_time' => date('Ymd'),
 722     );
 723     $activity = $this->callAPISuccess('Activity', 'create', $params);
 724
 725     // Check that from address is in "Source-Display-Name <source-email>"
 726     $formAddress = CRM_Case_BAO_Case::getReceiptFrom($activity['id']);
 727     $expectedFromAddress = sprintf("%s <%s>", $sourceDisplayName, $sourceContactParams['email']);
 728     $this->assertEquals($expectedFromAddress, $formAddress);
 729
 730     // Case 2: System Default From Address
 731     //  but first erase the email address of existing source contact ID
 732     $withoutEmailParams = array(
 733       'email' => '',
 734     );
 735     $sourceContactID = $this->individualCreate($withoutEmailParams);
 736     $params = array(
 737       'source_contact_id' => $sourceContactID,
 738       'subject' => 'Scheduling Meeting ' . substr(sha1(rand()), 0, 4),
 739       'activity_type_id' => CRM_Core_PseudoConstant::getKey('CRM_Activity_BAO_Activity', 'activity_type_id', 'Meeting'),
 740       'activity_date_time' => date('Ymd'),
 741     );
 742     $activity = $this->callAPISuccess('Activity', 'create', $params);
 743     // fetch domain info
 744     $domainInfo = $this->callAPISuccess('Domain', 'getsingle', array('id' => CRM_Core_Config::domainID()));
 745
 746     $formAddress = CRM_Case_BAO_Case::getReceiptFrom($activity['id']);
 747     if (!empty($domainInfo['from_email'])) {
 748       $expectedFromAddress = sprintf("%s <%s>", $domainInfo['from_name'], $domainInfo['from_email']);
 749     }
 750     // Case 3: fetch default Organization Contact email address
 751     elseif (!empty($domainInfo['domain_email'])) {
 752       $expectedFromAddress = sprintf("%s <%s>", $domainInfo['name'], $domainInfo['domain_email']);
 753     }
 754     // TODO: due to unknown reason the following assertion fails on
 755     //   test.civicrm.org test build but works fine on local
 756     // $this->assertEquals($expectedFromAddress, $formAddress);
 757
 758     // TODO: Case 4 about checking the $formAddress on basis of logged contact ID respectively needs,
 759     //  to change the domain setting, which isn't straight forward in test environment
 760   }
 761
 762   /**
 763    * Set up for testing activity queries.
 764    */
 765   protected function setUpForActivityDashboardTests() {
 766     $op = new PHPUnit_Extensions_Database_Operation_Insert();
 767     $op->execute($this->_dbconn,
 768       $this->createFlatXMLDataSet(
 769         dirname(__FILE__) . '/activities_for_dashboard_count.xml'
 770       )
 771     );
 772
 773     $this->_params = array(
 774       'contact_id' => NULL,
 775       'admin' => TRUE,
 776       'caseId' => NULL,
 777       'context' => 'home',
 778       'activity_type_id' => NULL,
 779       'offset' => 0,
 780       'rowCount' => 0,
 781       'sort' => NULL,
 782     );
 783   }
 784
 785 }