luos/tests/unit/workflow/engine/classes/WsBaseTest.php

<?php

use App\Jobs\EmailEvent;
use Faker\Factory;
use Illuminate\Support\Facades\Queue;
use ProcessMaker\Model\Application;
use ProcessMaker\Model\AppThread;
use ProcessMaker\Model\Delegation;
use ProcessMaker\Model\EmailServer;
use ProcessMaker\Model\Process;
use ProcessMaker\Model\Task;
use ProcessMaker\Model\User;
use Tests\TestCase;

class WsBaseTest extends TestCase
{
    /**
     * Constructor of the class.
     * 
     * @param string $name
     * @param array $data
     * @param string $dataName
     */
    public function __construct($name = null, array $data = [], $dataName = '')
    {
        parent::__construct($name, $data, $dataName);
    }

    /**
     * Sets up the fixture, for example, opens a network connection.
     * This method is called before a test is executed.
     */
    protected function setUp()
    {
        parent::setUp();
        Application::query()->truncate();
        AppThread::query()->truncate();
        Delegation::query()->truncate();
    }

    /**
     * Tears down the fixture, for example, closes a network connection.
     * This method is called after a test is executed.
     */
    protected function tearDown()
    {
        parent::tearDown();
    }

    /**
     * Create an application.
     * 
     * @param int $applicationNumber
     * @return \stdClass
     */
    private function createNewCase($applicationNumber = null)
    {
        if (empty($applicationNumber)) {
            $faker = Factory::create();
            $applicationNumber = $faker->unique()->numberBetween(1, 10000000);
        }
        $userUid = G::generateUniqueID();
        $processUid = G::generateUniqueID();
        $taskUid = G::generateUniqueID();
        $applicationUid = G::generateUniqueID();

        $appData = [
            'SYS_LANG' => 'en',
            'SYS_SKIN' => 'neoclassic',
            'SYS_SYS' => 'workflow',
            'APPLICATION' => G::generateUniqueID(),
            'PROCESS' => G::generateUniqueID(),
            'TASK' => '',
            'INDEX' => 2,
            'USER_LOGGED' => $userUid,
            'USR_USERNAME' => 'admin',
            'APP_NUMBER' => $applicationNumber,
            'PIN' => '97ZN'
        ];

        $user = factory(User::class)->create([
            'USR_UID' => $userUid
        ]);

        $process = factory(Process::class)->create([
            'PRO_UID' => $processUid
        ]);

        $task = factory(Task::class)->create([
            'PRO_UID' => $process->PRO_UID
        ]);

        $application = factory(Application::class)->create([
            'PRO_UID' => $process->PRO_UID,
            'APP_UID' => $applicationUid,
            'APP_NUMBER' => $applicationNumber,
            'APP_DATA' => serialize($appData)
        ]);

        $result = new stdClass();
        $result->userUid = $userUid;
        $result->processUid = $processUid;
        $result->taskUid = $taskUid;
        $result->applicationUid = $applicationUid;
        $result->applicationNumber = $applicationNumber;
        $result->appData = $appData;
        $result->user = $user;
        $result->process = $process;
        $result->task = $task;
        $result->application = $application;
        return $result;
    }

    /**
     * Create a email server configuration.
     * 
     * @return ProcessMaker\Model\EmailServer;
     */
    private function createEmailServer()
    {
        $passwordEnv = env('emailAccountPassword');
        $password = G::encrypt("hash:" . $passwordEnv, 'EMAILENCRYPT');
        $emailServer = factory(EmailServer::class)->create([
            'MESS_ENGINE' => env('emailEngine'),
            'MESS_SERVER' => env('emailServer'),
            'MESS_PORT' => env('emailPort'),
            'MESS_INCOMING_SERVER' => '',
            'MESS_INCOMING_PORT' => 0,
            'MESS_RAUTH' => 1,
            'MESS_ACCOUNT' => env('emailAccount'),
            'MESS_PASSWORD' => $password,
            'MESS_FROM_MAIL' => env('emailAccount'),
            'MESS_FROM_NAME' => '',
            'SMTPSECURE' => 'ssl',
            'MESS_TRY_SEND_INMEDIATLY' => 1,
            'MAIL_TO' => $password,
            'MESS_DEFAULT' => 1,
        ]);
        return $emailServer;
    }

    /**
     * Create a new template for send email.
     * 
     * @param string $proUid
     * @param string $usrUid
     * @return \ProcessMaker\Model\ProcessFiles
     */
    private function createTemplate($proUid, $usrUid)
    {
        $template = factory(\ProcessMaker\Model\ProcessFiles::class)->create([
            'PRO_UID' => $proUid,
            'USR_UID' => $usrUid,
            'PRF_PATH' => '/'
        ]);
        return $template;
    }

    /**
     * Create empty html.
     * 
     * @param string $content
     * @return string
     */
    private function createDefaultHtmlContent($content = '')
    {
        $string = ''
                . '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
                . '<html>'
                . '<head>'
                . '</head>'
                . '<body>'
                . $content
                . '</body>'
                . '</html>';
        return $string;
    }

    /**
     * This represents a collection of "messageType" for queue elements.
     */
    public function messageTypesWithQueue()
    {
        return [
            [WsBase::MESSAGE_TYPE_EMAIL_EVENT],
            [WsBase::MESSAGE_TYPE_PM_FUNCTION],
        ];
    }

    /**
     * This represents a collection of "messageType" for no queueable elements.
     */
    public function messageTypesWithoutQueue()
    {
        return [
            [WsBase::MESSAGE_TYPE_ACTIONS_BY_EMAIL],
            [WsBase::MESSAGE_TYPE_CASE_NOTE],
            [WsBase::MESSAGE_TYPE_EXTERNAL_REGISTRATION],
            [WsBase::MESSAGE_TYPE_RETRIEVE_PASSWORD],
            [WsBase::MESSAGE_TYPE_SOAP],
            [WsBase::MESSAGE_TYPE_TASK_NOTIFICATION],
            [WsBase::MESSAGE_TYPE_TEST_EMAIL],
        ];
    }

    /**
     * This should send an email of types elements to the work queue jobs.
     * Queue-fake has been used, see more at: https://laravel.com/docs/5.7/mocking#queue-fake
     * @test
     * @dataProvider messageTypesWithQueue
     * @covers \WsBase::sendMessage
     */
    public function it_should_send_an_sendMessage_with_queue_jobs($messageType)
    {
        //data
        $emailServer = $this->createEmailServer();
        $case = $this->createNewCase();
        $template = $this->createTemplate($case->process->PRO_UID, $case->user->USR_UID);

        //parameters
        $appUid = $case->applicationUid;
        $from = $emailServer->MESS_ACCOUNT;
        $to = $emailServer->MESS_ACCOUNT;
        $cc = "";
        $bcc = "";
        $subject = "test";
        $templateName = basename($template->PRF_PATH);
        $appFields = [];
        $attachment = [];
        $showMessage = true;
        $delIndex = 0;
        $config = $emailServer->toArray();
        $gmail = 0;
        $appMsgType = $messageType;

        //assertions
        Queue::fake();
        Queue::assertNothingPushed();

        $wsBase = new WsBase();
        $wsBase->sendMessage($appUid, $from, $to, $cc, $bcc, $subject, $templateName, $appFields, $attachment, $showMessage, $delIndex, $config, $gmail, $appMsgType);
        Queue::assertPushed(EmailEvent::class);
    }

    /**
     * This should send an email of types elements without work queue jobs.
     * Queue-fake has been used, see more at: https://laravel.com/docs/5.7/mocking#queue-fake
     * @test
     * @dataProvider messageTypesWithoutQueue
     * @covers \WsBase::sendMessage
     */
    public function it_should_execute_an_sendMessage_without_queue_jobs($messageTypes)
    {
        //data
        $emailServer = $this->createEmailServer();
        $case = $this->createNewCase();
        $template = $this->createTemplate($case->process->PRO_UID, $case->user->USR_UID);

        //parameters
        $appUid = $case->applicationUid;
        $from = $emailServer->MESS_ACCOUNT;
        $to = "";
        $cc = "";
        $bcc = "";
        $subject = "test";
        $templateName = basename($template->PRF_PATH);
        $appFields = [];
        $attachment = [];
        $showMessage = true;
        $delIndex = 0;
        $config = $emailServer->toArray();
        $gmail = 0;
        $appMsgType = $messageTypes;

        //assertions
        Queue::fake();
        Queue::assertNothingPushed();

        $wsBase = new WsBase();
        $wsBase->sendMessage($appUid, $from, $to, $cc, $bcc, $subject, $templateName, $appFields, $attachment, $showMessage, $delIndex, $config, $gmail, $appMsgType);
        Queue::assertNotPushed(EmailEvent::class);
    }

    /**
     * It should send an sendMessage with queue jobs and empty config parameter.
     * @test
     * @dataProvider messageTypesWithQueue
     * @covers \WsBase::sendMessage
     */
    public function it_should_send_an_sendMessage_with_queue_jobs_and_empty_config_parameter($messageTypes)
    {
        //data
        $emailServer = $this->createEmailServer();
        $case = $this->createNewCase();
        $template = $this->createTemplate($case->process->PRO_UID, $case->user->USR_UID);

        //parameters
        $appUid = $case->applicationUid;
        $from = $emailServer->MESS_ACCOUNT;
        $to = $emailServer->MESS_ACCOUNT;
        $cc = "";
        $bcc = "";
        $subject = "test";
        $templateName = basename($template->PRF_PATH);
        $appFields = [];
        $attachment = [];
        $showMessage = true;
        $delIndex = 0;
        $config = []; //with empty configuration
        $gmail = 0;
        $appMsgType = $messageTypes;

        //assertions
        Queue::fake();
        Queue::assertNothingPushed();

        $wsBase = new WsBase();
        $wsBase->sendMessage($appUid, $from, $to, $cc, $bcc, $subject, $templateName, $appFields, $attachment, $showMessage, $delIndex, $config, $gmail, $appMsgType);
        Queue::assertPushed(EmailEvent::class);
    }

    /**
     * It should send an sendMessage without queue jobs and empty config parameter.
     * @test
     * @dataProvider messageTypesWithoutQueue
     * @covers \WsBase::sendMessage
     */
    public function it_should_send_an_sendMessage_without_queue_jobs_and_empty_config_parameter($messageTypes)
    {
        //data
        $emailServer = $this->createEmailServer();
        $case = $this->createNewCase();
        $template = $this->createTemplate($case->process->PRO_UID, $case->user->USR_UID);

        //parameters
        $appUid = $case->applicationUid;
        $from = $emailServer->MESS_ACCOUNT;
        $to = "";
        $cc = "";
        $bcc = "";
        $subject = "test";
        $templateName = basename($template->PRF_PATH);
        $appFields = [];
        $attachment = [];
        $showMessage = true;
        $delIndex = 0;
        $config = []; //with empty configuration
        $gmail = 0;
        $appMsgType = $messageTypes;

        //assertions
        Queue::fake();
        Queue::assertNothingPushed();

        $wsBase = new WsBase();
        $wsBase->sendMessage($appUid, $from, $to, $cc, $bcc, $subject, $templateName, $appFields, $attachment, $showMessage, $delIndex, $config, $gmail, $appMsgType);
        Queue::assertNotPushed(EmailEvent::class);
    }

    /**
     * It should send an sendMessage with queue jobs and config parameter like id.
     * @test
     * @dataProvider messageTypesWithQueue
     * @covers \WsBase::sendMessage
     */
    public function it_should_send_an_sendMessage_with_queue_jobs_and_config_parameter_like_id($messageTypes)
    {
        //data
        $emailServer = $this->createEmailServer();
        $case = $this->createNewCase();
        $template = $this->createTemplate($case->process->PRO_UID, $case->user->USR_UID);

        //parameters
        $appUid = $case->applicationUid;
        $from = $emailServer->MESS_ACCOUNT;
        $to = $emailServer->MESS_ACCOUNT;
        $cc = "";
        $bcc = "";
        $subject = "test";
        $templateName = basename($template->PRF_PATH);
        $appFields = [];
        $attachment = [];
        $showMessage = true;
        $delIndex = 0;
        $config = $emailServer->MESS_UID; //With a valid Email Server Uid
        $gmail = 0;
        $appMsgType = $messageTypes;

        //assertions
        Queue::fake();
        Queue::assertNothingPushed();

        $wsBase = new WsBase();
        $wsBase->sendMessage($appUid, $from, $to, $cc, $bcc, $subject, $templateName, $appFields, $attachment, $showMessage, $delIndex, $config, $gmail, $appMsgType);
        Queue::assertPushed(EmailEvent::class);
    }

    /**
     * It should send an sendMessage without queue jobs and config parameter like id.
     * @test
     * @dataProvider messageTypesWithoutQueue
     * @covers \WsBase::sendMessage
     */
    public function it_should_send_an_sendMessage_without_queue_jobs_and_config_parameter_like_id($messageTypes)
    {
        //data
        $emailServer = $this->createEmailServer();
        $case = $this->createNewCase();
        $template = $this->createTemplate($case->process->PRO_UID, $case->user->USR_UID);

        //parameters
        $appUid = $case->applicationUid;
        $from = $emailServer->MESS_ACCOUNT;
        $to = "";
        $cc = "";
        $bcc = "";
        $subject = "test";
        $templateName = basename($template->PRF_PATH);
        $appFields = [];
        $attachment = [];
        $showMessage = true;
        $delIndex = 0;
        $config = $emailServer->MESS_UID; //With a valid Email Server Uid
        $gmail = 0;
        $appMsgType = $messageTypes;

        //assertions
        Queue::fake();
        Queue::assertNothingPushed();

        $wsBase = new WsBase();
        $wsBase->sendMessage($appUid, $from, $to, $cc, $bcc, $subject, $templateName, $appFields, $attachment, $showMessage, $delIndex, $config, $gmail, $appMsgType);
        Queue::assertNotPushed(EmailEvent::class);
    }

    /**
     * It should send an sendMessage without queue jobs and gmail parameter like one.
     * @test
     * @dataProvider messageTypesWithoutQueue
     * @covers \WsBase::sendMessage
     */
    public function it_should_send_an_sendMessage_without_queue_jobs_and_gmail_parameter_like_one($messageTypes)
    {
        //data
        $emailServer = $this->createEmailServer();
        $case = $this->createNewCase();
        $template = $this->createTemplate($case->process->PRO_UID, $case->user->USR_UID);

        //parameters
        $appUid = $case->applicationUid;
        $from = $emailServer->MESS_ACCOUNT;
        $to = "";
        $cc = "";
        $bcc = "";
        $subject = "test";
        $templateName = basename($template->PRF_PATH);
        $appFields = [];
        $attachment = [];
        $showMessage = true;
        $delIndex = 0;
        $config = $emailServer->MESS_UID;
        $gmail = 1; //GMail flag enabled
        $appMsgType = $messageTypes;

        //assertions
        Queue::fake();
        Queue::assertNothingPushed();

        $wsBase = new WsBase();
        $wsBase->sendMessage($appUid, $from, $to, $cc, $bcc, $subject, $templateName, $appFields, $attachment, $showMessage, $delIndex, $config, $gmail, $appMsgType);
        Queue::assertNotPushed(EmailEvent::class);
    }

    /**
     * Test that the casesList method returns the case title value
     *
     * @test
     * @covers \WsBase::caseList
     */
    public function it_should_test_that_the_cases_list_method_returns_the_case_title()
    {
        //Create the user factory
        $user = factory(User::class)->create();

        //Create the application factory
        $application1 = factory(Application::class)->create(
            [
                'APP_STATUS' => 'TO_DO',
                'APP_TITLE' => 'Title1'
            ]
        );
        $application2 = factory(Application::class)->create(
            [
                'APP_STATUS' => 'DRAFT',
                'APP_TITLE' => 'Title2'
            ]
        );

        //Create the delegation factory
        $delegation1 = factory(Delegation::class)->create(
            [
                'USR_UID' => $user->USR_UID,
                'DEL_THREAD_STATUS' => 'OPEN',
                'DEL_FINISH_DATE' => null,
                'APP_NUMBER' => $application1->APP_NUMBER
            ]
        );
        $delegation2 = factory(Delegation::class)->create(
            [
                'USR_UID' => $user->USR_UID,
                'DEL_THREAD_STATUS' => 'OPEN',
                'DEL_FINISH_DATE' => null,
                'APP_NUMBER' => $application2->APP_NUMBER
            ]
        );

        //Create app thread factory
        factory(AppThread::class)->create(
            [
                'APP_THREAD_STATUS' => 'OPEN',
                'APP_UID' => $delegation1->APP_UID
            ]
        );
        factory(AppThread::class)->create(
            [
                'APP_THREAD_STATUS' => 'OPEN',
                'APP_UID' => $delegation2->APP_UID
            ]
        );

        //Instance the object
        $wsBase = new WsBase();
        //Call the caseList method
        $res = $wsBase->caseList($user->USR_UID);

        //Assert the result has 2 rows
        $this->assertCount(2, $res);

        //Assert the status of the case
        $this->assertTrue('TO_DO' || 'DRAFT' == $res[0]['status']);
        $this->assertTrue('TO_DO' || 'DRAFT' == $res[1]['status']);

        //Assert the case title is returned
        $this->assertTrue($application1->APP_TITLE || $application2->APP_TITLE == $res[0]['name']);
        $this->assertTrue($application1->APP_TITLE || $application2->APP_TITLE == $res[1]['name']);
    }

    /**
     * Test the casesList method when the result is empty
     *
     * @test
     * @covers \WsBase::caseList
     */
    public function it_should_test_the_cases_list_method_when_there_are_no_results()
    {
        //Create the user factory
        $user1 = factory(User::class)->create();
        $user2 = factory(User::class)->create();

        //Create the application factory
        $application1 = factory(Application::class)->create(
            [
                'APP_STATUS' => 'TO_DO',
                'APP_TITLE' => 'Title1'
            ]
        );
        $application2 = factory(Application::class)->create(
            [
                'APP_STATUS' => 'DRAFT',
                'APP_TITLE' => 'Title2'
            ]
        );

        //Create the delegation factory
        $delegation1 = factory(Delegation::class)->create(
            [
                'USR_UID' => $user1->USR_UID,
                'DEL_THREAD_STATUS' => 'OPEN',
                'DEL_FINISH_DATE' => null,
                'APP_NUMBER' => $application1->APP_NUMBER
            ]
        );
        $delegation2 = factory(Delegation::class)->create(
            [
                'USR_UID' => $user1->USR_UID,
                'DEL_THREAD_STATUS' => 'OPEN',
                'DEL_FINISH_DATE' => null,
                'APP_NUMBER' => $application2->APP_NUMBER
            ]
        );

        //Create app thread factory
        factory(AppThread::class)->create(
            [
                'APP_THREAD_STATUS' => 'OPEN',
                'APP_UID' => $delegation1->APP_UID
            ]
        );
        factory(AppThread::class)->create(
            [
                'APP_THREAD_STATUS' => 'OPEN',
                'APP_UID' => $delegation2->APP_UID
            ]
        );

        //Instance the object
        $wsBase = new WsBase();

        //Call the caseList method
        $res = $wsBase->caseList($user2->USR_UID);

        //Assert the result his empty
        $this->assertEmpty($res);
    }
}