PKPNotificationManagerTest.php

<?php
 
import('lib.pkp.tests.PKPTestCase');
import('lib.pkp.classes.notification.PKPNotificationManager');
import('lib.pkp.classes.mail.MailTemplate');
 
define('NOTIFICATION_ID', 1);
 
class PKPNotificationManagerTest extends PKPTestCase {
 
   private $notificationMgr;
 
   public function testGetNotificationMessage() {
      $notification = $this->getTrivialNotification();
      $notification->setType(NOTIFICATION_TYPE_REVIEW_ASSIGNMENT);
 
      $requestDummy = $this->getMockBuilder(PKPRequest::class)->getMock();
      $result = $this->notificationMgr->getNotificationMessage($requestDummy, $notification);
 
      $this->assertEquals('##notification.type.reviewAssignment##', $result);
   }
 
   function testCreateNotification($notification, $notificationParams = array()) {
      $notificationMgrStub = $this->getMgrStubForCreateNotificationTests();
      $this->injectNotificationDaoMock($notification);
 
      if (!empty($notificationParams)) {
         $this->injectNotificationSettingsDaoMock($notificationParams);
      }
 
      $result = $this->exerciseCreateNotification($notificationMgrStub, $notification, $notificationParams);
 
      $this->assertEquals($notification, $result);
   }
 
   function testCreateNotificationBlocked() {
      $trivialNotification = $this->getTrivialNotification();
 
      $blockedNotificationTypes = array($trivialNotification->getType());
      $notificationMgrStub = $this->getMgrStubForCreateNotificationTests($blockedNotificationTypes);
 
      $result = $this->exerciseCreateNotification($notificationMgrStub, $trivialNotification);
 
      $this->assertEquals(null, $result);
   }
 
   function testCreateNotificationEmailed($notification, $notificationParams = array()) {
      $nonTrivialNotification = $notification;
 
      // Make the notification non trivial.
      $nonTrivialNotification->setLevel(NOTIFICATION_LEVEL_NORMAL);
 
      // Setup any assoc type and id that have content definition in notification manager,
      // so we can check it later when sending the email.
      $nonTrivialNotification->setType(NOTIFICATION_TYPE_NEW_ANNOUNCEMENT);
      $nonTrivialNotification->setAssocType(ASSOC_TYPE_ANNOUNCEMENT);
 
      $fixtureObjects = $this->getFixtureCreateNotificationSendEmail($nonTrivialNotification);
      list($notificationMgrStub, $requestStub) = $fixtureObjects;
      $this->injectNotificationDaoMock($nonTrivialNotification);
 
      if (!empty($notificationParams)) {
         $this->injectNotificationSettingsDaoMock($notificationParams);
      }
 
      $result = $this->exerciseCreateNotification($notificationMgrStub, $nonTrivialNotification, $notificationParams, $requestStub);
 
      $this->assertEquals($nonTrivialNotification, $result);
   }
 
   function testCreateNotificationTrivialNotEmailed() {
      // Trivial notifications should never be emailed.
      $trivialNotification = $this->getTrivialNotification();
      $emailedNotificationTypes = array($trivialNotification->getType());
 
      $notificationMgrStub = $this->getMgrStubForCreateNotificationTests(array(), $emailedNotificationTypes, array('sendNotificationEmail'));
      // Make sure the sendNotificationEmail method will never be called.
      $notificationMgrMock = $notificationMgrStub;
      $notificationMgrMock->expects($this->never())
                          ->method('sendNotificationEmail');
 
      $this->injectNotificationDaoMock($trivialNotification);
 
      $result = $this->exerciseCreateNotification($notificationMgrMock, $trivialNotification);
 
      $this->assertEquals($trivialNotification, $result);
   }
 
   public function testCreateTrivialNotification($notification, $notificationParams = array()) {
      $trivialNotification = $notification;
      // Adapt the notification to the expected result.
      $trivialNotification->unsetData('assocId');
      $trivialNotification->unsetData('assocType');
      $trivialNotification->setType(NOTIFICATION_TYPE_SUCCESS);
 
      $this->injectNotificationDaoMock($trivialNotification);
      if (!empty($notificationParams)) {
         $this->injectNotificationSettingsDaoMock($notificationParams);
      }
 
      $result = $this->notificationMgr->createTrivialNotification($trivialNotification->getUserId());
 
      $this->assertEquals($trivialNotification, $result);
   }
 
   public function trivialNotificationDataProvider() {
      $trivialNotification = $this->getTrivialNotification();
      $notificationParams = array('param1' => 'param1Value');
      $data = array();
 
      $data[] = array($trivialNotification);
      $data[] = array($trivialNotification, $notificationParams);
 
      return $data;
   }
 
   //
   // Protected methods.
   //
   protected function getMockedDAOs() {
      return array('NotificationDAO', 'NotificationSettingsDAO', 'UserDAO');
   }
 
   protected function setUp() : void {
      parent::setUp();
 
      $this->notificationMgr = new PKPNotificationManager();
   }
 
   //
   // Helper methods.
   //
   private function exerciseCreateNotification($notificationMgr, $notificationToCreate, $notificationToCreateParams = array(), $request = null) {
      if (is_null($request)) {
         $request = $this->getMockBuilder(PKPRequest::class)->getMock();
      }
 
      return $notificationMgr->createNotification(
         $request,
         $notificationToCreate->getUserId(),
         $notificationToCreate->getType(),
         $notificationToCreate->getContextId(),
         $notificationToCreate->getAssocType(),
         $notificationToCreate->getAssocId(),
         $notificationToCreate->getLevel(),
         $notificationToCreateParams);
   }
   private function getFixtureCreateNotificationSendEmail($expectedNotification) {
      // Add the notification type to the emailed notifications set.
      $emailedNotifications = array($expectedNotification->getType());
      $notificationMgrStub = $this->getMgrStubForCreateNotificationTests(array(), $emailedNotifications, array('getMailTemplate'));
 
      // Stub a PKPRequest object.
      $requestStub = $this->getMockBuilder(PKPRequest::class)
         ->setMethods(array('getSite', 'getContext', 'getUserVar'))
         ->getMock();
 
      // Some site, user and notification data are required for composing the email.
      // Retrieve/define them so we can check later.
      $siteTitle = 'Site title';
      $siteContactName = 'Site contact name';
      $siteEmail = 'site@email.com';
      $userFirstName = 'FirstName';
      $userLastName = 'UserLastName';
      $userEmail = 'user@email.com';
      $notificationContents = $notificationMgrStub->getNotificationContents($requestStub, $expectedNotification);
      $contextTitle = 'Context title';
 
      // Build a test user object.
      import('lib.pkp.classes.user.User');
      $testUser = new User();
      $testUser->setId($expectedNotification->getUserId());
      $testUser->setGivenName($userFirstName, 'en_US');
      $testUser->setFamilyName($userLastName, 'en_US');
      $testUser->setEmail($userEmail);
 
      // Get the user full name to check.
      $userFullName = $testUser->getFullName();
 
      // Stub context.
      $application = Application::get();
      $contextDao = $application->getContextDAO();
      $contextStub = $this->getMockBuilder(get_class($contextDao->newDataObject()))
         ->setMethods(array('getLocalizedName', 'getContactName', 'getContactEmail'))
         ->getMock();
      $contextStub->expects($this->any())
                  ->method('getLocalizedName')
                  ->will($this->returnValue($contextTitle));
      $contextStub->expects($this->any())
                  ->method('getContactName')
                  ->will($this->returnValue($siteContactName));
      $contextStub->expects($this->any())
                  ->method('getContactEmail')
                  ->will($this->returnValue($siteEmail));
 
      // Inject context stub into our request stub.
      $requestStub->expects($this->any())
                  ->method('getContext')
                  ->will($this->returnValue($contextStub));
      $requestStub->expects($this->any())
         ->method('getUserVar')
         ->will($this->returnValue(null));
      Registry::set('request', $requestStub);
 
      // Stub site.
      $siteStub = $this->getMockBuilder(Site::class)
         ->setMethods(array('getLocalizedContactName', 'getLocalizedTitle', 'getLocalizedContactEmail'))
         ->getMock();
 
      $siteStub->expects($this->any())
               ->method('getLocalizedContactName')
               ->will($this->returnValue($siteContactName));
      $siteStub->expects($this->any())
               ->method('getLocalizedTitle')
               ->will($this->returnValue($siteTitle));
      $siteStub->expects($this->any())
               ->method('getLocalizedContactEmail')
               ->will($this->returnValue($siteEmail));
 
      // Inject site stub into our request stub.
      $requestStub->expects($this->any())
                  ->method('getSite')
                  ->will($this->returnValue($siteStub));
 
      // Mock MailTemplate class so we can verify
      // notification manager interaction with it. Avoid
      // calling the mail template original constructor.
      $mailTemplateMock = $this->getMockBuilder(MailTemplate::class)
         ->setMethods(array('setReplyTo', 'addRecipient', 'assignParams', 'send'))
         ->setConstructorArgs(array(null, 'en_US', $contextStub))
         ->getMock();
 
      $mailTemplateMock->expects($this->any())
                       ->method('setReplyTo')
                       ->with($this->equalTo($siteEmail), $this->equalTo($siteContactName));
      $mailTemplateMock->expects($this->any())
                       ->method('addRecipient')
                       ->with($this->equalTo($userEmail), $this->equalTo($userFullName));
      $mailTemplateMock->expects($this->any())
                       ->method('assignParams')
                       ->with($this->logicalAnd($this->contains($notificationContents), $this->contains($contextTitle)));
      $mailTemplateMock->expects($this->once())
                       ->method('send')
                  ->will($this->returnValue(true));
 
      // Inject our MailTemplate mock in notification manager.
      $notificationMgrStub->expects($this->any())
                          ->method('getMailTemplate')
                          ->will($this->returnValue($mailTemplateMock));
 
      // Register a UserDao stub to return the test user.
      $userDaoStub = $this->getMockBuilder(UserDAO::class)
         ->setMethods(array('getById'))
         ->getMock();
      $userDaoStub->expects($this->any())
                  ->method('getById')
                  ->will($this->returnValue($testUser));
      DAORegistry::registerDAO('UserDAO', $userDaoStub);
 
      return array($notificationMgrStub, $requestStub);
   }
 
   private function getMgrStubForCreateNotificationTests($blockedNotifications = array(), $emailedNotifications = array(), $extraOpToStub = array()) {
      $notificationMgrStub = $this->getMockBuilder(PKPNotificationManager::class)
         ->setMethods(array_merge($extraOpToStub, array('getUserBlockedNotifications', 'getEmailedNotifications', 'getNotificationUrl')))
         ->getMock();
 
      $notificationMgrStub->expects($this->any())
         ->method('getUserBlockedNotifications')
         ->will($this->returnValue($blockedNotifications));
 
      $notificationMgrStub->expects($this->any())
         ->method('getEmailedNotifications')
         ->will($this->returnValue($emailedNotifications));
 
      $notificationMgrStub->expects($this->any())
         ->method('getNotificationUrl')
         ->will($this->returnValue('anyNotificationUrl'));
 
      return $notificationMgrStub;
   }
 
   private function injectNotificationDaoMock($notification) {
      $notificationDaoMock = $this->getMockBuilder(NotificationDAO::class)
         ->setMethods(array('insertObject'))
         ->getMock();
      $notificationDaoMock->expects($this->once())
                          ->method('insertObject')
                          ->with($this->equalTo($notification))
                          ->will($this->returnValue(NOTIFICATION_ID));
 
      DAORegistry::registerDAO('NotificationDAO', $notificationDaoMock);
   }
 
   private function injectNotificationSettingsDaoMock($notificationParams) {
      // Mock NotificationSettingsDAO.
      $notificationSettingsDaoMock = $this->getMockBuilder(NotificationSettingsDAO::class)->getMock();
      $notificationSettingsDaoMock->expects($this->any())
                                  ->method('updateNotificationSetting')
                                  ->with($this->equalTo(NOTIFICATION_ID),
                                       $this->equalTo(key($notificationParams)),
                                       $this->equalTo(current($notificationParams)));
 
      // Inject notification settings DAO mock.
      DAORegistry::registerDAO('NotificationSettingsDAO', $notificationSettingsDaoMock);
   }
 
   private function getTrivialNotification() {
      $notificationDao = DAORegistry::getDAO('NotificationDAO');
      $notification = $notificationDao->newDataObject();
      $anyTestInteger = 1;
      $notification->setUserId($anyTestInteger);
      $notification->setType($anyTestInteger);
      $notification->setContextId(CONTEXT_ID_NONE);
      $notification->setAssocType($anyTestInteger);
      $notification->setAssocId($anyTestInteger);
      $notification->setLevel(NOTIFICATION_LEVEL_TRIVIAL);
 
      return $notification;
   }
}