Merge branch '2015.11-develop'
[tine20] / tests / tine20 / Felamimail / Frontend / JsonTest.php
1 <?php
2
3 use Sabre\DAV;
4
5 /**
6  * Tine 2.0 - http://www.tine20.org
7  *
8  * @package     Felamimail
9  * @license     http://www.gnu.org/licenses/agpl.html
10  * @copyright   Copyright (c) 2009-2014 Metaways Infosystems GmbH (http://www.metaways.de)
11  * @author      Philipp Schüle <p.schuele@metaways.de>
12  */
13
14 /**
15  * Test helper
16  */
17 require_once dirname(dirname(dirname(__FILE__))) . DIRECTORY_SEPARATOR . 'TestHelper.php';
18
19 /**
20  * Test class for Tinebase_Group
21  */
22 class Felamimail_Frontend_JsonTest extends TestCase
23 {
24     /**
25      * @var Felamimail_Frontend_Json
26      */
27     protected $_json = array();
28
29     /**
30      * message ids to delete
31      *
32      * @var array
33      */
34     protected $_messageIds = array();
35     
36     /**
37      * @var Felamimail_Model_Account
38      */
39     protected $_account = NULL;
40     
41     /**
42      * imap backend
43
44      * @var Felamimail_Backend_ImapProxy
45      */
46     protected $_imap = NULL;
47     
48     /**
49      * name of the folder to use for tests
50      * @var string
51      */
52     protected $_testFolderName = 'Junk';
53     
54     /**
55      * folders to delete in tearDown()
56      * 
57      * @var array
58      */
59     protected $_createdFolders = array();
60
61     /**
62      * are there messages to delete?
63      * 
64      * @var array
65      */
66     protected $_foldersToClear = array();
67
68     /**
69      * active sieve script name to be restored
70      *
71      * @var string
72      */
73     protected $_oldActiveSieveScriptName = NULL;
74
75     /**
76      * was sieve_vacation_active ?
77      *
78      * @var boolean
79      */
80     protected $_oldSieveVacationActiveState = FALSE;
81     
82     /**
83      * old sieve data
84      *
85      * @var Felamimail_Sieve_Backend_Sql
86      */
87     protected $_oldSieveData = NULL;
88
89     /**
90      * sieve script name to delete
91      *
92      * @var string
93      */
94     protected $_testSieveScriptName = NULL;
95
96     /**
97      * sieve vacation template file name
98      *
99      * @var string
100      */
101     protected $_sieveVacationTemplateFile = 'vacation_template.tpl';
102
103     /**
104      * test email domain
105      *
106      * @var string
107      */
108     protected $_mailDomain = 'tine20.org';
109
110     /**
111      * @var Felamimail_Model_Folder
112      */
113     protected $_folder = NULL;
114
115     /**
116      * paths in the vfs to delete
117      *
118      * @var array
119      */
120     protected $_pathsToDelete = array();
121
122     /**
123      *
124      * @var Tinebase_Frontend_Json
125      */
126     protected $_frontend = NULL;
127     
128     /**
129      * Sets up the fixture.
130      * This method is called before a test is executed.
131      *
132      * @access protected
133      */
134     protected function setUp()
135     {
136         Tinebase_TransactionManager::getInstance()->startTransaction(Tinebase_Core::getDb());
137         
138         // get (or create) test accout
139         $this->_account = Felamimail_Controller_Account::getInstance()->search()->getFirstRecord();
140         $this->_oldSieveVacationActiveState = $this->_account->sieve_vacation_active;
141         try {
142             $this->_oldSieveData = new Felamimail_Sieve_Backend_Sql($this->_account);
143         } catch (Tinebase_Exception_NotFound $tenf) {
144             // do nothing
145         }
146         
147         $this->_json = new Felamimail_Frontend_Json();
148         $this->_imap = Felamimail_Backend_ImapFactory::factory($this->_account);
149         
150         foreach (array($this->_testFolderName, $this->_account->sent_folder, $this->_account->trash_folder) as $folderToCreate) {
151             // create folder if it does not exist
152             $this->_getFolder($folderToCreate);
153         }
154         
155         $this->_mailDomain = TestServer::getPrimaryMailDomain();
156
157         $this->_frontend = new Tinebase_Frontend_Json();
158     }
159
160     /**
161      * Tears down the fixture
162      * This method is called after a test is executed.
163      *
164      * @access protected
165      */
166     protected function tearDown()
167     {
168         if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
169             . ' Tearing down ...');
170         
171         if (count($this->_createdFolders) > 0) {
172             foreach ($this->_createdFolders as $folderName) {
173                 //echo "delete $folderName\n";
174                 try {
175                     $this->_imap->removeFolder(Felamimail_Model_Folder::encodeFolderName($folderName));
176                 } catch (Zend_Mail_Storage_Exception $zmse) {
177                     // already deleted
178                 }
179             }
180             Felamimail_Controller_Cache_Folder::getInstance()->clear($this->_account);
181         }
182         
183         if (! empty($this->_foldersToClear)) {
184             foreach ($this->_foldersToClear as $folderName) {
185                 // delete test messages from given folders on imap server (search by special header)
186                 $this->_imap->selectFolder($folderName);
187                 $result = $this->_imap->search(array(
188                     'HEADER X-Tine20TestMessage jsontest'
189                 ));
190                 //print_r($result);
191                 foreach ($result as $messageUid) {
192                     $this->_imap->removeMessage($messageUid);
193                 }
194                 
195                 // clear message cache
196                 $folder = Felamimail_Controller_Folder::getInstance()->getByBackendAndGlobalName($this->_account->getId(), $folderName);
197                 Felamimail_Controller_Cache_Message::getInstance()->clear($folder);
198             }
199         }
200         
201         // sieve cleanup
202         if ($this->_testSieveScriptName !== NULL) {
203             Felamimail_Controller_Sieve::getInstance()->setScriptName($this->_testSieveScriptName);
204             try {
205                 Felamimail_Controller_Sieve::getInstance()->deleteScript($this->_account->getId());
206             } catch (Zend_Mail_Protocol_Exception $zmpe) {
207                 // do not delete script if active
208             }
209             Felamimail_Controller_Account::getInstance()->setVacationActive($this->_account, $this->_oldSieveVacationActiveState);
210             
211             if ($this->_oldSieveData !== NULL) {
212                 $this->_oldSieveData->save();
213             }
214         }
215         if ($this->_oldActiveSieveScriptName !== NULL) {
216             Felamimail_Controller_Sieve::getInstance()->setScriptName($this->_oldActiveSieveScriptName);
217             Felamimail_Controller_Sieve::getInstance()->activateScript($this->_account->getId());
218         }
219         
220         // vfs cleanup
221         foreach ($this->_pathsToDelete as $path) {
222             $webdavRoot = new DAV\ObjectTree(new Tinebase_WebDav_Root());
223             //echo "delete $path";
224             $webdavRoot->delete($path);
225         }
226         
227         Tinebase_TransactionManager::getInstance()->rollBack();
228     }
229
230     /************************ test functions *********************************/
231     
232     /*********************** folder tests ****************************/
233     
234     /**
235      * test search folders (check order of folders as well)
236      */
237     public function testSearchFolders()
238     {
239         $filter = $this->_getFolderFilter();
240         $result = $this->_json->searchFolders($filter);
241         
242         $this->assertGreaterThan(1, $result['totalcount']);
243         $expectedFolders = array('INBOX', $this->_testFolderName, $this->_account->trash_folder, $this->_account->sent_folder);
244         
245         $foundCount = 0;
246         foreach ($result['results'] as $index => $folder) {
247             if (in_array($folder['localname'], $expectedFolders)) {
248                 $foundCount++;
249             }
250         }
251         $this->assertEquals(count($expectedFolders), $foundCount);
252     }
253     
254     /**
255      * clear test folder
256      */
257     public function testClearFolder()
258     {
259         $folderName = $this->_testFolderName;
260         $folder = $this->_getFolder($this->_testFolderName);
261         $folder = Felamimail_Controller_Folder::getInstance()->emptyFolder($folder->getId());
262
263         $filter = $this->_getMessageFilter($folder->getId());
264         $result = $this->_json->searchMessages($filter, '');
265         
266         $this->assertEquals(0, $result['totalcount'], 'Found too many messages in folder ' . $this->_testFolderName);
267         $this->assertEquals(0, $folder->cache_totalcount);
268     }
269
270     /**
271      * try to create some folders
272      */
273     public function testCreateFolders()
274     {
275         $filter = $this->_getFolderFilter();
276         $result = $this->_json->searchFolders($filter);
277         
278         $foldernames = array('test' => 'test', 'Schlüssel' => 'Schlüssel', 'test//1' => 'test1', 'test\2' => 'test2');
279         
280         foreach ($foldernames as $foldername => $expected) {
281             $result = $this->_json->addFolder($foldername, $this->_testFolderName, $this->_account->getId());
282             $globalname = $this->_testFolderName . $this->_account->delimiter . $expected;
283             $this->_createdFolders[] = $globalname;
284             $this->assertEquals($expected, $result['localname']);
285             $this->assertEquals($globalname, $result['globalname']);
286             $this->assertEquals(Felamimail_Model_Folder::CACHE_STATUS_EMPTY, $result['cache_status']);
287         }
288     }
289     
290     /**
291      * test emtpy folder (with subfolder)
292      */
293     public function testEmptyFolderWithSubfolder()
294     {
295         $folderName = $this->_testFolderName;
296         $folder = $this->_getFolder($this->_testFolderName);
297         $this->testCreateFolders();
298         
299         $folderArray = $this->_json->emptyFolder($folder->getId());
300         $this->assertEquals(0, $folderArray['has_children']);
301         
302         $result = $this->_json->updateFolderCache($this->_account->getId(), $this->_testFolderName);
303         $this->assertEquals(0, count($result));
304     }
305     
306     /**
307      * testUpdateFolderCache
308      */
309     public function testUpdateFolderCache()
310     {
311         $result = $this->_json->updateFolderCache($this->_account->getId(), '');
312         
313         // create folders directly on imap server
314         $this->_imap->createFolder('test', $this->_testFolderName, $this->_account->delimiter);
315         $this->_imap->createFolder('testsub', $this->_testFolderName . $this->_account->delimiter . 'test', $this->_account->delimiter);
316         // if something goes wrong, we need to delete these folders in tearDown
317         $this->_createdFolders[] = $this->_testFolderName . $this->_account->delimiter . 'test' . $this->_account->delimiter . 'testsub';
318         $this->_createdFolders[] = $this->_testFolderName . $this->_account->delimiter . 'test';
319         
320         if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
321             . ' Update cache and check if folder is found');
322         
323         $result = $this->_json->updateFolderCache($this->_account->getId(), $this->_testFolderName);
324         $testfolder = $result[0];
325         $this->assertGreaterThan(0, count($result));
326         $this->assertEquals($this->_testFolderName . $this->_account->delimiter . 'test', $testfolder['globalname']);
327         $this->assertEquals(TRUE, (bool)$testfolder['has_children'], 'should have children');
328         
329         if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
330             . ' Delete subfolder directly on imap server');
331         
332         $this->_imap->removeFolder($this->_testFolderName . $this->_account->delimiter . 'test' . $this->_account->delimiter . 'testsub');
333         array_shift($this->_createdFolders);
334         
335         if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
336             . ' Check if has_children got updated and folder is removed from cache');
337         
338         $this->_json->updateFolderCache($this->_account->getId(), '');
339         $testfolder = $this->_getFolder($this->_testFolderName . $this->_account->delimiter . 'test');
340         $this->assertEquals(FALSE, (bool)$testfolder['has_children'], 'should have no children');
341
342         return $testfolder;
343     }
344     
345     /**
346      * testUpdateFolderCacheOfNonexistantFolder
347      *
348      * @see 0009800: unselectable folder with subfolders disappears
349      */
350     public function testUpdateFolderCacheOfNonexistantFolder()
351     {
352         $testfolder = $this->testUpdateFolderCache();
353         
354         try {
355             $folderName = $this->_testFolderName . $this->_account->delimiter . 'test' . $this->_account->delimiter . 'testsub';
356             if (Tinebase_Core::isLogLevel(Zend_Log::DEBUG)) Tinebase_Core::getLogger()->debug(__METHOD__ . '::' . __LINE__
357                 . ' Trying to fetch deleted folder ' . $folderName);
358             
359             $testfoldersub = Felamimail_Controller_Folder::getInstance()->getByBackendAndGlobalName($this->_account->getId(), $folderName);
360             $this->fail('Tinebase_Exception_NotFound expected when looking for folder ' . $folderName);
361         } catch (Tinebase_Exception_NotFound $tenf) {
362         }
363         
364         $this->_imap->removeFolder($this->_testFolderName . $this->_account->delimiter . 'test');
365         array_shift($this->_createdFolders);
366         
367         // try to update message cache of nonexistant folder
368         $removedTestfolder = $this->_json->updateMessageCache($testfolder['id'], 1);
369         $this->assertEquals(0, $removedTestfolder['is_selectable'], 'Folder should not be selectable');
370         
371         // update cache and check if folder is deleted
372         $result = $this->_json->updateFolderCache($this->_account->getId(), $this->_testFolderName);
373         $this->assertEquals(0, count($result));
374     }
375     
376     /*********************** accounts tests **************************/
377     
378     /**
379      * test search for accounts and check default account from config
380      */
381     public function testSearchAccounts()
382     {
383         $system = $this->_getSystemAccount();
384         
385         $this->assertTrue(! empty($system), 'no accounts found');
386         if (TestServer::getInstance()->getConfig()->mailserver) {
387             $this->assertEquals(TestServer::getInstance()->getConfig()->mailserver, $system['host']);
388             $this->assertEquals(TestServer::getInstance()->getConfig()->mailserver, $system['sieve_hostname']);
389         }
390     }
391     
392     /**
393      * get system account
394      *
395      * @return array
396      */
397     protected function _getSystemAccount()
398     {
399         $results = $this->_json->searchAccounts(array());
400         
401         $this->assertGreaterThan(0, $results['totalcount']);
402         $system = array();
403         foreach ($results['results'] as $result) {
404             if ($result['name'] == Tinebase_Core::getUser()->accountLoginName . '@' . $this->_mailDomain) {
405                 $system = $result;
406             }
407         }
408         
409         return $system;
410     }
411     
412     /**
413      * test change / delete of account
414      */
415     public function testChangeDeleteAccount()
416     {
417         $system = $this->_getSystemAccount();
418         unset($system['id']);
419         $system['type'] = Felamimail_Model_Account::TYPE_USER;
420         $account = $this->_json->saveAccount($system);
421         
422         $accountRecord = new Felamimail_Model_Account($account, TRUE);
423         $accountRecord->resolveCredentials(FALSE);
424         if (TestServer::getInstance()->getConfig()->mailserver) {
425             $this->assertEquals(TestServer::getInstance()->getConfig()->mailserver, $account['host']);
426         }
427         
428         $this->_json->changeCredentials($account['id'], $accountRecord->user, 'neuespasswort');
429         $account = $this->_json->getAccount($account['id']);
430         
431         $accountRecord = new Felamimail_Model_Account($account, TRUE);
432         $accountRecord->resolveCredentials(FALSE);
433         $this->assertEquals('neuespasswort', $accountRecord->password);
434         
435         $this->_json->deleteAccounts($account['id']);
436     }
437     
438     /*********************** message tests ****************************/
439     
440     /**
441      * test update message cache
442      */
443     public function testUpdateMessageCache()
444     {
445         $message = $this->_sendMessage();
446         $inbox = $this->_getFolder('INBOX');
447         // update message cache and check result
448         $result = $this->_json->updateMessageCache($inbox['id'], 30);
449         
450         if ($result['cache_status'] == Felamimail_Model_Folder::CACHE_STATUS_COMPLETE) {
451             $this->assertEquals($result['imap_totalcount'], $result['cache_totalcount'], 'totalcounts should be equal');
452         } else if ($result['cache_status'] == Felamimail_Model_Folder::CACHE_STATUS_INCOMPLETE) {
453             $this->assertNotEquals(0, $result['cache_job_actions_est']);
454         }
455     }
456     
457     /**
458      * test folder status
459      */
460     public function testGetFolderStatus()
461     {
462         $filter = $this->_getFolderFilter();
463         $result = $this->_json->searchFolders($filter);
464         $this->assertGreaterThan(1, $result['totalcount']);
465         $expectedFolders = array('INBOX', $this->_testFolderName, $this->_account->trash_folder, $this->_account->sent_folder);
466         
467         foreach ($result['results'] as $folder) {
468             $this->_json->updateMessageCache($folder['id'], 30);
469         }
470         
471         $message = $this->_sendMessage();
472         
473         $status = $this->_json->getFolderStatus(array(array('field' => 'account_id', 'operator' => 'equals', 'value' => $this->_account->getId())));
474         $this->assertEquals(1, count($status));
475         $this->assertEquals($this->_account->sent_folder, $status[0]['localname']);
476     }
477
478     /**
479      * test folder status of deleted folder
480      *
481      * @see 0007134: getFolderStatus should ignore non-existent folders
482      */
483     public function testGetFolderStatusOfDeletedFolder()
484     {
485         $this->testCreateFolders();
486         // remove one of the created folders
487         $removedFolder = $this->_createdFolders[0];
488         $this->_imap->removeFolder(Felamimail_Model_Folder::encodeFolderName($removedFolder));
489         
490         $status = $this->_json->getFolderStatus(array(array('field' => 'account_id', 'operator' => 'equals', 'value' => $this->_account->getId())));
491         $this->assertGreaterThan(2, count($status), 'Expected more than 2 folders that need an update: ' . print_r($status, TRUE));
492         foreach ($status as $folder) {
493             if ($folder['globalname'] == $removedFolder) {
494                 $this->fail('removed folder should not appear in status array!');
495             }
496         }
497     }
498     
499     /**
500      * test send message
501      */
502     public function testSendMessage()
503     {
504         // set email to unittest@tine20.org
505         $contactFilter = new Addressbook_Model_ContactFilter(array(
506             array('field' => 'n_family', 'operator' => 'equals', 'value' => 'Clever')
507         ));
508         $contactIds = Addressbook_Controller_Contact::getInstance()->search($contactFilter, NULL, FALSE, TRUE);
509         $this->assertTrue(count($contactIds) > 0, 'sclever not found in addressbook');
510
511         $contact = Addressbook_Controller_Contact::getInstance()->get($contactIds[0]);
512         $originalEmail =  $contact->email;
513         $contact->email = $this->_account->email;
514         $contact = Addressbook_Controller_Contact::getInstance()->update($contact, FALSE);
515
516         // send email
517         $messageToSend = $this->_getMessageData('unittestalias@' . $this->_mailDomain);
518         $messageToSend['note'] = 1;
519         $messageToSend['bcc']  = array(Tinebase_Core::getUser()->accountEmailAddress);
520         //print_r($messageToSend);
521         $returned = $this->_json->saveMessage($messageToSend);
522         $this->_foldersToClear = array('INBOX', $this->_account->sent_folder);
523         
524         // check if message is in sent folder
525         $message = $this->_searchForMessageBySubject($messageToSend['subject'], $this->_account->sent_folder);
526         $this->assertEquals($message['from_email'], $messageToSend['from_email']);
527         $this->assertTrue(isset($message['to'][0]));
528         $this->assertEquals($message['to'][0],      $messageToSend['to'][0], 'recipient not found');
529         $this->assertEquals($message['bcc'][0],     $messageToSend['bcc'][0], 'bcc recipient not found');
530         $this->assertEquals($message['subject'],    $messageToSend['subject']);
531         
532         $this->_checkEmailNote($contact, $messageToSend['subject']);
533         
534         // reset sclevers original email address
535         $contact->email = $originalEmail;
536         Addressbook_Controller_Contact::getInstance()->update($contact, FALSE);
537     }
538     
539     /**
540      * check email note
541      *
542      * @param Addressbook_Model_Contact $contact
543      * @param string $subject
544      */
545     protected function _checkEmailNote($contact, $subject)
546     {
547         // check if email note has been added to contact(s)
548         $contact = Addressbook_Controller_Contact::getInstance()->get($contact->getId());
549         $emailNoteType = Tinebase_Notes::getInstance()->getNoteTypeByName('email');
550         
551         // check / delete notes
552         $emailNotes = new Tinebase_Record_RecordSet('Tinebase_Model_Note');
553         foreach ($contact->notes as $note) {
554             if ($note->note_type_id == $emailNoteType->getId()) {
555                 $this->assertContains($subject, $note->note, 'did not find note subject');
556                 $this->assertEquals(Tinebase_Core::getUser()->getId(), $note->created_by);
557                 $this->assertContains('aaaaaä', $note->note);
558                 $emailNotes->addRecord($note);
559             }
560         }
561         $this->assertGreaterThan(0, $emailNotes->count(), 'no email notes found');
562         Tinebase_Notes::getInstance()->deleteNotes($emailNotes);
563     }
564
565     /**
566      * test send message to invalid recipient
567      */
568     public function testSendMessageToInvalidRecipient()
569     {
570         $messageToSend = $this->_getMessageData($this->_account->email);
571         $invalidEmail = 'invaliduser@' . $this->_mailDomain;
572         $messageToSend['to'] = array($invalidEmail);
573         
574         try {
575             $returned = $this->_json->saveMessage($messageToSend);
576             $this->fail('Tinebase_Exception_SystemGeneric expected');
577         } catch (Tinebase_Exception_SystemGeneric $tesg) {
578             $this->assertContains('5.1.1 <' . $invalidEmail . '>: Recipient address rejected', $tesg->getMessage(),
579                 'exception message did not match: ' . $tesg->getMessage());
580         }
581     }
582     
583     /**
584      * try to get a message from imap server (with complete body, attachments, etc)
585      *
586      * @see 0006300: add unique message-id header to new messages (for message-id check)
587      */
588     public function testGetMessage()
589     {
590         $message = $this->_sendMessage();
591         
592         // get complete message
593         $message = $this->_json->getMessage($message['id']);
594         
595         // check
596         $this->assertTrue(isset($message['headers']) && $message['headers']['message-id']);
597         $this->assertContains('@' . $this->_mailDomain, $message['headers']['message-id']);
598         $this->assertGreaterThan(0, preg_match('/aaaaaä/', $message['body']));
599         
600         // delete message on imap server and check if correct exception is thrown when trying to get it
601         $this->_imap->selectFolder('INBOX');
602         $this->_imap->removeMessage($message['messageuid']);
603         Tinebase_Core::getCache()->clean();
604         $this->setExpectedException('Felamimail_Exception_IMAPMessageNotFound');
605         $message = $this->_json->getMessage($message['id']);
606     }
607     
608     /**
609      * try to get a message as plain/text
610      */
611     public function testGetPlainTextMessage()
612     {
613         $accountBackend = new Felamimail_Backend_Account();
614         $message = $this->_sendMessage();
615         
616         // get complete message
617         $this->_account->display_format = Felamimail_Model_Account::DISPLAY_PLAIN;
618         $accountBackend->update($this->_account);
619         $message = $this->_json->getMessage($message['id']);
620         $this->_account->display_format = Felamimail_Model_Account::DISPLAY_HTML;
621         $accountBackend->update($this->_account);
622         
623         // check
624         $this->assertEquals("aaaaaä \n\r\n", $message['body']);
625     }
626     
627     /**
628      * try search for a message with path filter
629      */
630     public function testSearchMessageWithPathFilter()
631     {
632         $sentMessage = $this->_sendMessage();
633         $filter = array(array(
634             'field' => 'path', 'operator' => 'in', 'value' => '/' . $this->_account->getId()
635         ));
636         $result = $this->_json->searchMessages($filter, '');
637         $message = $this->_getMessageFromSearchResult($result, $sentMessage['subject']);
638         $this->assertTrue(! empty($message), 'Sent message not found with account path filter');
639
640         $inbox = $this->_getFolder('INBOX');
641         $filter = array(array(
642             'field' => 'path', 'operator' => 'in', 'value' => '/' . $this->_account->getId() . '/' . $inbox->getId()
643         ));
644         $result = $this->_json->searchMessages($filter, '');
645         $message = $this->_getMessageFromSearchResult($result, $sentMessage['subject']);
646         $this->assertTrue(! empty($message), 'Sent message not found with path filter');
647         foreach ($result['results'] as $mail) {
648             $this->assertEquals($inbox->getId(), $mail['folder_id'], 'message is in wrong folder: ' . print_r($mail, TRUE));
649         }
650     }
651     
652     /**
653      * try search for a message with all inboxes and flags filter
654      */
655     public function testSearchMessageWithAllInboxesFilter()
656     {
657         $sentMessage = $this->_sendMessage();
658         $filter = array(
659             array('field' => 'path',  'operator' => 'in',       'value' => Felamimail_Model_MessageFilter::PATH_ALLINBOXES),
660             array('field' => 'flags', 'operator' => 'notin',    'value' => Zend_Mail_Storage::FLAG_FLAGGED),
661         );
662         $result = $this->_json->searchMessages($filter, '');
663         $this->assertGreaterThan(0, $result['totalcount']);
664         $this->assertEquals($result['totalcount'], count($result['results']));
665         
666         $message = $this->_getMessageFromSearchResult($result, $sentMessage['subject']);
667         $this->assertTrue(! empty($message), 'Sent message not found with all inboxes filter');
668     }
669     
670     /**
671      * try search for a message with three cache filters to force a foreign relation join with at least 2 tables
672      */
673     public function testSearchMessageWithThreeCacheFilter()
674     {
675         $filter = array(
676             array('field' => 'flags',   'operator' => 'in',       'value' => Zend_Mail_Storage::FLAG_ANSWERED),
677             array('field' => 'to',      'operator' => 'contains', 'value' => 'testDOESNOTEXIST'),
678             array('field' => 'subject', 'operator' => 'contains', 'value' => 'testDOESNOTEXIST'),
679         );
680         $result = $this->_json->searchMessages($filter, '');
681         $this->assertEquals(0, $result['totalcount']);
682     }
683     
684     /**
685      * try search for a message with empty path filter
686      */
687     public function testSearchMessageEmptyPath()
688     {
689         $sentMessage = $this->_sendMessage();
690         
691         $filter = array(
692             array('field' => 'path',  'operator' => 'equals',   'value' => ''),
693         );
694         $result = $this->_json->searchMessages($filter, '');
695         
696         $this->assertEquals(0, $result['totalcount']);
697         $accountFilterFound = FALSE;
698         
699         foreach ($result['filter'] as $filter) {
700             if ($filter['field'] === 'account_id' && empty($filter['value'])) {
701                 $accountFilterFound = TRUE;
702                 break;
703             }
704         }
705         $this->assertTrue($accountFilterFound);
706     }
707     
708     /**
709      * test flags (add + clear + deleted)
710      */
711     public function testAddAndClearFlags()
712     {
713         $message = $this->_sendMessage();
714         $inboxBefore = $this->_getFolder('INBOX');
715         
716         $this->_json->addFlags($message['id'], Zend_Mail_Storage::FLAG_SEEN);
717         
718         // check if unread count got decreased
719         $inboxAfter = $this->_getFolder('INBOX');
720         $this->assertTrue($inboxBefore->cache_unreadcount - 1 == $inboxAfter->cache_unreadcount, 'wrong cache unreadcount');
721         
722         $message = $this->_json->getMessage($message['id']);
723         $this->assertTrue(in_array(Zend_Mail_Storage::FLAG_SEEN, $message['flags']), 'seen flag not set');
724         
725         // try with a filter
726         $filter = array(
727             array('field' => 'id', 'operator' => 'in', array($message['id']))
728         );
729         $this->_json->clearFlags($filter, Zend_Mail_Storage::FLAG_SEEN);
730         
731         $message = $this->_json->getMessage($message['id']);
732         $this->assertFalse(in_array(Zend_Mail_Storage::FLAG_SEEN, $message['flags']), 'seen flag should not be set');
733
734         $this->setExpectedException('Tinebase_Exception_NotFound');
735         $this->_json->addFlags(array($message['id']), Zend_Mail_Storage::FLAG_DELETED);
736         $this->_json->getMessage($message['id']);
737     }
738     
739     /**
740      * testMarkFolderRead
741      *
742      * @see 0009812: mark folder as read does not work with pgsql
743      */
744     public function testMarkFolderRead()
745     {
746         $inboxBefore = $this->_getFolder('INBOX');
747         $filter = array(array(
748             'field' => 'folder_id', 'operator' => 'equals', 'value' => $inboxBefore->getId()
749         ), array(
750             'field' => 'flags', 'operator' => 'notin', 'value' => array(Zend_Mail_Storage::FLAG_SEEN)
751         ));
752         $this->_json->addFlags($filter, Zend_Mail_Storage::FLAG_SEEN);
753         
754         $inboxAfter = $this->_getFolder('INBOX');
755         $this->assertEquals(0, $inboxAfter->cache_unreadcount);
756     }
757     
758     /**
759      * test delete from trash
760      */
761     public function testDeleteFromTrashWithFilter()
762     {
763         $message = $this->_sendMessage();
764         $this->_foldersToClear = array('INBOX', $this->_account->sent_folder, $this->_account->trash_folder);
765         
766         $trash = $this->_getFolder($this->_account->trash_folder);
767         $result = $this->_json->moveMessages(array(array(
768             'field' => 'id', 'operator' => 'in', 'value' => array($message['id'])
769         )), $trash->getId());
770
771         $messageInTrash = $this->_searchForMessageBySubject($message['subject'], $this->_account->trash_folder);
772         
773         // delete messages in trash with filter
774         $this->_json->addFlags(array(array(
775             'field' => 'folder_id', 'operator' => 'equals', 'value' => $trash->getId()
776         ), array(
777             'field' => 'id', 'operator' => 'in', 'value' => array($messageInTrash['id'])
778         )), Zend_Mail_Storage::FLAG_DELETED);
779         
780         $this->setExpectedException('Tinebase_Exception_NotFound');
781         $this->_json->getMessage($messageInTrash['id']);
782     }
783     
784     /**
785      * move message to trash with trash folder constant (Felamimail_Model_Folder::FOLDER_TRASH)
786      */
787     public function testMoveMessagesToTrash()
788     {
789         $message = $this->_sendMessage();
790         $this->_foldersToClear = array('INBOX', $this->_account->sent_folder, $this->_account->trash_folder);
791         
792         $result = $this->_json->moveMessages(array(array(
793             'field' => 'id', 'operator' => 'in', 'value' => array($message['id'])
794         )), Felamimail_Model_Folder::FOLDER_TRASH);
795
796         $messageInTrash = $this->_searchForMessageBySubject($message['subject'], $this->_account->trash_folder);
797     }
798     
799     /**
800      * test reply mail and check some headers
801      *
802      * @see 0006106: Add References header / https://forge.tine20.org/mantisbt/view.php?id=6106
803      */
804     public function testReplyMessage()
805     {
806         $message = $this->_sendMessage();
807         
808         $replyMessage = $this->_getReply($message);
809         $returned = $this->_json->saveMessage($replyMessage);
810         
811         $result = $this->_getMessages();
812         
813         $replyMessageFound = array();
814         $originalMessage = array();
815         foreach ($result['results'] as $mail) {
816             if ($mail['subject'] == $replyMessage['subject']) {
817                 $replyMessageFound = $mail;
818             }
819             if ($mail['subject'] == $message['subject']) {
820                 $originalMessage = $mail;
821             }
822         }
823         $replyMessageFound = $this->_json->getMessage($replyMessageFound['id']);
824         $originalMessage = $this->_json->getMessage($originalMessage['id']);
825         
826         $this->assertTrue(! empty($replyMessageFound), 'replied message not found');
827         $this->assertTrue(! empty($originalMessage), 'original message not found');
828         
829         // check headers
830         $this->assertTrue(isset($replyMessageFound['headers']['in-reply-to']));
831         $this->assertEquals($originalMessage['headers']['message-id'], $replyMessageFound['headers']['in-reply-to']);
832         $this->assertTrue(isset($replyMessageFound['headers']['references']));
833         $this->assertEquals($originalMessage['headers']['message-id'], $replyMessageFound['headers']['references']);
834         
835         // check answered flag
836         $this->assertTrue(in_array(Zend_Mail_Storage::FLAG_ANSWERED, $originalMessage['flags'], 'could not find flag'));
837     }
838     
839     /**
840      * get reply message data
841      *
842      * @param array $_original
843      * @return array
844      */
845     protected function _getReply($_original)
846     {
847         $replyMessage               = $this->_getMessageData();
848         $replyMessage['subject']    = 'Re: ' . $_original['subject'];
849         $replyMessage['original_id']= $_original['id'];
850         $replyMessage['flags']      = Zend_Mail_Storage::FLAG_ANSWERED;
851         
852         return $replyMessage;
853     }
854
855     /**
856      * test reply mail in sent folder
857      */
858     public function testReplyMessageInSentFolder()
859     {
860         $messageInSent = $this->_sendMessage($this->_account->sent_folder);
861         $replyMessage = $this->_getReply($messageInSent);
862         $returned = $this->_json->saveMessage($replyMessage);
863         
864         $result = $this->_getMessages();
865         $sentMessage = $this->_getMessageFromSearchResult($result, $replyMessage['subject']);
866         $this->assertTrue(! empty($sentMessage));
867     }
868
869     /**
870      * test reply mail with long references header
871      *
872      * @see 0006644: "At least one mail header line is too long"
873      */
874     public function testReplyMessageWithLongHeader()
875     {
876         $messageInSent = $this->_sendMessage($this->_account->sent_folder, array(
877             'references' => '<c95d8187-2c71-437e-adb8-5e1dcdbdc507@email.test.org>
878    <2601bbfa-566e-4490-a3db-aad005733d32@email.test.org>
879    <20120530154350.1854610131@ganymed.de>
880    <7e393ce1-d193-44fc-bf5f-30c61a271fe6@email.test.org>
881    <4FC8B49C.8040704@funk.de>
882    <dba2ad5c-6726-4171-8710-984847c010a1@email.test.org>
883    <20120601123551.5E98610131@ganymed.de>
884    <f1cc3195-8641-46e3-8f20-f60f3e16b107@email.test.org>
885    <20120619093658.37E4210131@ganymed.de>
886    <CA+6Rn2PX2Q3tOk2tCQfCjcaC8zYS5XZX327OoyJfUb+w87vCLQ@mail.net.com>
887    <20120619130652.03DD310131@ganymed.de>
888    <37616c6a-4c47-4b54-9ca6-56875bc9205d@email.test.org>
889    <20120620074843.42E2010131@ganymed.de>
890    <CA+6Rn2MAb2x0qeSfcaW6F=0S7LEQL442Sx2ha9RtwMs4B0esBg@mail.net.com>
891    <20120620092902.88C8C10131@ganymed.de>
892    <c95d8187-2c71-437e-adb8-5e1dcdbdc507@email.test.org>
893    <2601bbfa-566e-4490-a3db-aad005733d32@email.test.org>
894    <20120530154350.1854610131@ganymed.de>
895    <7e393ce1-d193-44fc-bf5f-30c61a271fe6@email.test.org>
896    <4FC8B49C.8040704@funk.de>
897    <dba2ad5c-6726-4171-8710-984847c010a1@email.test.org>
898    <20120601123551.5E98610131@ganymed.de>
899    <f1cc3195-8641-46e3-8f20-f60f3e16b107@email.test.org>
900    <20120619093658.37E4210131@ganymed.de>
901    <CA+6Rn2PX2Q3tOk2tCQfCjcaC8zYS5XZX327OoyJfUb+w87vCLQ@mail.net.com>
902    <20120619130652.03DD310131@ganymed.de>
903    <37616c6a-4c47-4b54-9ca6-56875bc9205d@email.test.org>
904    <20120620074843.42E2010131@ganymed.de>
905    <CA+6Rn2MAb2x0qeSfcaW6F=0S7LEQL442Sx2ha9RtwMs4B0esBg@mail.net.com>
906    <20120620092902.88C8C10131@ganymed.de>'
907         ));
908         $replyMessage = $this->_getReply($messageInSent);
909         $returned = $this->_json->saveMessage($replyMessage);
910         
911         $result = $this->_getMessages();
912         $sentMessage = $this->_getMessageFromSearchResult($result, $replyMessage['subject']);
913         $this->assertTrue(! empty($sentMessage));
914     }
915     
916     /**
917      * test move
918      */
919     public function testMoveMessage()
920     {
921         $message = $this->_sendMessage();
922         $this->_foldersToClear = array('INBOX', $this->_account->sent_folder, $this->_testFolderName);
923         
924         $inbox = $this->_getFolder('INBOX');
925         $inboxBefore = $this->_json->updateMessageCache($inbox['id'], 30);
926         
927         // move
928         $testFolder = $this->_getFolder($this->_testFolderName);
929         $result = $this->_json->moveMessages(array(array(
930             'field' => 'id', 'operator' => 'in', 'value' => array($message['id'])
931         )), $testFolder->getId());
932
933         $inboxAfter = $this->_getFolder('INBOX');
934         
935         // check if count was decreased correctly
936         $this->assertEquals($inboxBefore['cache_unreadcount'] - 1, $inboxAfter['cache_unreadcount']);
937         $this->assertEquals($inboxBefore['cache_totalcount'] - 1, $inboxAfter['cache_totalcount']);
938         
939         $result = $this->_getMessages($this->_testFolderName);
940         $movedMessage = array();
941         foreach ($result['results'] as $mail) {
942             if ($mail['subject'] == $message['subject']) {
943                 $movedMessage = $mail;
944             }
945         }
946         $this->assertTrue(! empty($movedMessage), 'moved message not found');
947     }
948     
949     /**
950      * forward message test
951      *
952      * @see 0007624: losing umlauts in attached filenames
953      */
954     public function testForwardMessageWithAttachment()
955     {
956         $testFolder = $this->_getFolder($this->_testFolderName);
957         $message = fopen(dirname(__FILE__) . '/../files/multipart_related.eml', 'r');
958         Felamimail_Controller_Message::getInstance()->appendMessage($testFolder, $message);
959         
960         $subject = 'Tine 2.0 bei Metaways - Verbessurngsvorschlag';
961         $message = $this->_searchForMessageBySubject($subject, $this->_testFolderName);
962         
963         $fwdSubject = 'Fwd: ' . $subject;
964         $forwardMessageData = array(
965             'account_id'    => $this->_account->getId(),
966             'subject'       => $fwdSubject,
967             'to'            => array($this->_getEmailAddress()),
968             'body'          => "aaaaaä <br>",
969             'headers'       => array('X-Tine20TestMessage' => 'jsontest'),
970             'original_id'   => $message['id'],
971             'attachments'   => array(new Tinebase_Model_TempFile(array(
972                 'type'  => Felamimail_Model_Message::CONTENT_TYPE_MESSAGE_RFC822,
973                 'name'  => 'Verbessurüngsvorschlag',
974             ), TRUE)),
975             'flags'         => Zend_Mail_Storage::FLAG_PASSED,
976         );
977         
978         $this->_foldersToClear[] = 'INBOX';
979         $this->_json->saveMessage($forwardMessageData);
980         $forwardMessage = $this->_searchForMessageBySubject($fwdSubject);
981         
982         // check attachment name
983         $forwardMessageComplete = $this->_json->getMessage($forwardMessage['id']);
984         $this->assertEquals(1, count($forwardMessageComplete['attachments']));
985         $this->assertEquals('Verbessurüngsvorschlag.eml', $forwardMessageComplete['attachments'][0]['filename'], 'umlaut missing from attachment filename');
986         
987         $forwardMessage = $this->_json->getMessage($forwardMessage['id']);
988         $this->assertTrue((isset($forwardMessage['structure']) || array_key_exists('structure', $forwardMessage)), 'structure should be set when fetching complete message: ' . print_r($forwardMessage, TRUE));
989         $this->assertEquals(Felamimail_Model_Message::CONTENT_TYPE_MESSAGE_RFC822, $forwardMessage['structure']['parts'][2]['contentType']);
990         
991         $message = $this->_json->getMessage($message['id']);
992         $this->assertTrue(in_array(Zend_Mail_Storage::FLAG_PASSED, $message['flags']), 'forwarded flag missing in flags: ' . print_r($message, TRUE));
993     }
994     
995     /**
996      * testSendMessageWithAttachmentWithoutExtension
997      *
998      * @see 0008328: email attachment without file extension is not sent properly
999      */
1000     public function testSendMessageWithAttachmentWithoutExtension()
1001     {
1002         $subject = 'attachment test';
1003         $messageToSend = $this->_getMessageData('unittestalias@' . $this->_mailDomain, $subject);
1004         $tempfileName = 'jsontest' . Tinebase_Record_Abstract::generateUID(10);
1005         $tempfilePath = Tinebase_Core::getTempDir() . DIRECTORY_SEPARATOR . $tempfileName;
1006         file_put_contents($tempfilePath, 'some content');
1007         $tempFile = Tinebase_TempFile::getInstance()->createTempFile($tempfilePath, $tempfileName);
1008         $messageToSend['attachments'] = array(array('tempFile' => array('id' => $tempFile->getId())));
1009         $this->_json->saveMessage($messageToSend);
1010         $forwardMessage = $this->_searchForMessageBySubject($subject);
1011         $this->_foldersToClear = array('INBOX', $this->_account->sent_folder);
1012         
1013         $fullMessage = $this->_json->getMessage($forwardMessage['id']);
1014         $this->assertTrue(count($fullMessage['attachments']) === 1);
1015         $attachment = $fullMessage['attachments'][0];
1016         $this->assertContains($tempfileName, $attachment['filename'], 'wrong attachment filename: ' . print_r($attachment, TRUE));
1017         $this->assertEquals(16, $attachment['size'], 'wrong attachment size: ' . print_r($attachment, TRUE));
1018     }
1019     
1020     /**
1021      * save message in folder (draft) test
1022      *
1023      * @see 0007178: BCC does not save the draft message
1024      */
1025     public function testSaveMessageInFolder()
1026     {
1027         $messageToSave = $this->_getMessageData();
1028         $messageToSave['bcc'] = array('bccaddress@email.org', 'bccaddress2@email.org');
1029         
1030         $draftsFolder = $this->_getFolder($this->_account->drafts_folder);
1031         $returned = $this->_json->saveMessageInFolder($this->_account->drafts_folder, $messageToSave);
1032         $this->_foldersToClear = array($this->_account->drafts_folder);
1033         
1034         // check if message is in drafts folder and recipients are present
1035         $message = $this->_searchForMessageBySubject($messageToSave['subject'], $this->_account->drafts_folder);
1036         $this->assertEquals($messageToSave['subject'],  $message['subject']);
1037         $this->assertEquals($messageToSave['to'][0],    $message['to'][0], 'recipient not found');
1038         $this->assertEquals(2, count($message['bcc']), 'bcc recipient not found: ' . print_r($message, TRUE));
1039         $this->assertEquals($messageToSave['bcc'][0],   $message['bcc'][0], '1st bcc recipient not found');
1040         $this->assertEquals($messageToSave['bcc'][1],   $message['bcc'][1], '2nd bcc recipient not found');
1041     }
1042     
1043     /**
1044      * testSendReadingConfirmation
1045      *
1046      * @see 0007736: ask user before sending reading confirmation
1047      * @see 0008402: Wrong recipient with read confirmation
1048      */
1049     public function testSendReadingConfirmation()
1050     {
1051         $messageToSave = $this->_getMessageData();
1052         $messageToSave['headers']['disposition-notification-to'] = '"' . Tinebase_Core::getUser()->accountFullName . '" <' . $this->_account->email . '>';
1053         $returned = $this->_json->saveMessageInFolder($this->_testFolderName, $messageToSave);
1054         $messageWithReadingConfirmationHeader = $this->_searchForMessageBySubject($messageToSave['subject'], $this->_testFolderName);
1055         $this->_messageIds[] = $messageWithReadingConfirmationHeader['id'];
1056         $this->_json->sendReadingConfirmation($messageWithReadingConfirmationHeader['id']);
1057         
1058         $translate = Tinebase_Translation::getTranslation('Felamimail');
1059         $subject = $translate->_('Reading Confirmation:') . ' '. $messageToSave['subject'];
1060         $message = $this->_searchForMessageBySubject($subject);
1061         $this->_messageIds[] = $message['id'];
1062         
1063         $complete = $this->_json->getMessage($message['id']);
1064         $this->assertContains($translate->_('Was read by:') . ' ' . $this->_account->from, $complete['body']);
1065     }
1066
1067     /**
1068      * save message in non-existant folder (templates) test
1069      *
1070      * @see 0008476: Drafts are not working
1071      */
1072     public function testSaveMessageInNonExistantTemplatesFolder()
1073     {
1074         $messageToSave = $this->_getMessageData();
1075         
1076         $templatesFolder = $this->_getFolder($this->_account->templates_folder, FALSE);
1077         if ($templatesFolder) {
1078             $this->_json->deleteFolder($templatesFolder['id'], $this->_account->getId());
1079         }
1080         $returned = $this->_json->saveMessageInFolder($this->_account->templates_folder, $messageToSave);
1081         $this->_foldersToClear = array($this->_account->templates_folder);
1082         
1083         // check if message is in templates folder
1084         $message = $this->_searchForMessageBySubject($messageToSave['subject'], $this->_account->templates_folder);
1085         $this->assertEquals($messageToSave['subject'],  $message['subject']);
1086         $this->assertEquals($messageToSave['to'][0],    $message['to'][0], 'recipient not found');
1087     }
1088     
1089     /**
1090      * testSaveMessageNoteWithInvalidChar
1091      *
1092      * @see 0008644: error when sending mail with note (wrong charset)
1093      */
1094     public function testSaveMessageNoteWithInvalidChar()
1095     {
1096         $subject = Tinebase_Core::filterInputForDatabase("\xF0\x9F\x98\x8A\xC2"); // :-) emoji &nbsp;
1097         $messageData = $this->_getMessageData('', $subject);
1098         $messageData['note'] = true;
1099         $messageData['body'] .= "&nbsp;";
1100         
1101         $this->_foldersToClear[] = 'INBOX';
1102         $this->_json->saveMessage($messageData);
1103         $message = $this->_searchForMessageBySubject($subject);
1104         
1105         $contact = Addressbook_Controller_Contact::getInstance()->getContactByUserId(Tinebase_Core::getUser()->getId());
1106         $this->_checkEmailNote($contact, $subject);
1107     }
1108     
1109     /**
1110      * testSaveMessageNoteWithInvalidChar
1111      *
1112      * @see 0008644: error when sending mail with note (wrong charset)
1113      */
1114     public function testSaveMessageWithInvalidChar()
1115     {
1116         $subject = "\xF0\x9F\x98\x8A"; // :-) emoji
1117         $messageData = $this->_getMessageData('', $subject);
1118         $this->_foldersToClear[] = 'INBOX';
1119         $this->_json->saveMessage($messageData);
1120         $message = $this->_searchForMessageBySubject(Tinebase_Core::filterInputForDatabase($subject));
1121     }
1122     
1123     /**
1124      * testMessageWithInvalidICS
1125      *
1126      * @see 0008786: broken ics causes js error when showing details
1127      */
1128     public function testMessageWithInvalidICS()
1129     {
1130         $inbox = $this->_getFolder('INBOX');
1131         $mailAsString = file_get_contents(dirname(__FILE__) . '/../files/invalidimip.eml');
1132         Felamimail_Controller_Message::getInstance()->appendMessage($inbox, $mailAsString);
1133         
1134         $this->_foldersToClear = array('INBOX');
1135         $message = $this->_searchForMessageBySubject('test invalid imip');
1136         
1137         $fullMessage = $this->_json->getMessage($message['id']);
1138         $this->assertTrue(empty($fullMessage->preparedParts));
1139     }
1140
1141     /**
1142      * testSendMailveopeAPIMessage
1143      *
1144      * - envolpe amored message into PGP MIME structure
1145      */
1146     public function testSendMailveopeAPIMessage()
1147     {
1148         $subject = 'testSendMailveopeAPIMessage';
1149         $messageData = $this->_getMessageData('', $subject);
1150         $messageData['body'] = '-----BEGIN PGP MESSAGE-----
1151 Version: Mailvelope v1.3.3
1152 Comment: https://www.mailvelope.com
1153
1154 wcFMA/0LJF28pDbGAQ//YgtsmEZN+pgIJiBDb7iYwPEOchDRIEjGOx543KF6
1155 5YigW9p39pfcJgvGfT8x9cUIrYGxyw5idPSOEftYXyjjGaOYGaKpRSR4hI83
1156 OcJSlEHKq72xhg04mNpCjjJ8dLBstPcQ7tDtsA8Nfb4PwkUYB9IhIBnARg+n
1157 NvrN8mSA2UnY9ElFCvf30sar8EuM5swAjbk64C8TIypMy/Bg4T93zRdxwik6
1158 7BCcbOpm/2PTsiVYBOTcU4+XdG5eyTENXH58M6UTxTD4/g7Qi5PjN+PxyXqf
1159 v2Y1k9F49Y1egf2QJ2r4PX0EWS8SaynSHiIoBsp1xb07nLwZwCdMPG1QNPpF
1160 l2FqlS4dEuQTdkv0deMvd7gtiNynRTAVcJc1ZC6RuWJ+EH2jA49XWkn14eRC
1161 e5jMtPPudkhubnN9Je5lwatGKbJGyuXh+IaM0E0WQMZ3dm8+ST1l4WpVuGbw
1162 KozLUiTRJP9UoxWOcwpQOnzcSlc4rHmWdtF0y3usM9u9GPREqpNUWkEyEEuv
1163 XdZE7rKKj22dJHLCXxAQEh3m29Y2WVaq50YbtEZ+SwwbrHhxP4+FJEru+byh
1164 fiZ47sVW2KvYGJPvbFoSZHiSvMecxDg8BVwe+naZXww/Rwa/TlaX4bYyzpUG
1165 KeJUAzWEfFpJ0+yAvMGQEC7psIJ9NCx149C4ujiQmajSwhUB3XANcmCGB0wm
1166 JjcqC4AHvc7/t4MrQZm0F/W+nrMmNqbZk+gylVrPs9rFEqu7wbjwTmsFA3sS
1167 LkenvQIxBali6uzCR+nd09REqcYirG9cLti39DW048lhhG/ml+gAxxNEaSpG
1168 NbIoV/3w8n7sAIM1fjuHne8bX0gWG43TTjU8MwSMryG7tCOG5u+Cebh6TAoY
1169 NzbX2dpDhOYq5zXdCgKU4P3eh0csSs4UrqFT3TdAxIGrQJ7KrXvB6+N8gRZo
1170 FcUaR+zrRPJjPUZfi46ecP5SG/tM5ea1hqvkwEnEpqjLmCUxqB+rfxx46USX
1171 hMZd2ukUv6kEKv3EUDsRYu1SlDLhDLhWNx8RJae5XkMR+eUUMyNNVwbeMQbB
1172 VAcMcaPITTk84sH7XElr9eF6sCUN4V79OSBRPGY/aNGrcwcoDSD4Hwu+Lw9w
1173 Q+1n8EQ66gAkbJzCNd5GaYMZR9echkBaD/rdWDS3ktcrMehra+h44MTQONV9
1174 8W+RI+IT5jaIXtB4jePmGjsJjbC9aEhTRBRkUnPA7phgknc52dD74AY/6lzK
1175 yd4uZ6S3vhurJW0Vt4iBWJzhFNiSODh5PzteeNzCVAkGMsQvy1IHk0d3uzcE
1176 0tEuSh8fZOFGB4fvMx9Mk8oAU92wfj4J7AVpSo5oRdxMqAXfaYKqfr2Gn++q
1177 E5LClhVIBbFXclCoe0RYNz4wtxjeeYbP40Bq5g0JvPutD/dBMp8hz8Qt+yyG
1178 d8X4/KmQIXyFZ8aP17GMckE5GVVvY9y89eWnWuTUJdwM540hB/EJNeHHTE5y
1179 N2FSLGcmNkvE+3H7BczQ2ZI1SZDhof+umbUst0qoQW+hHmY3CSma48yGAVox
1180 52u2t7hosHCfpf631Ve/6fcICo8vJ2Qfufu2BGIMlSfx4WzUuaMQBynuxFSa
1181 IbVx8ZTO7dJRKrg72aFmWTf0uNla7vicAhpiLWobyNYcZbIjrAGDfg==
1182 =BaAn
1183 -----END PGP MESSAGE-----';
1184
1185         $this->_foldersToClear[] = 'INBOX';
1186         $this->_json->saveMessage($messageData);
1187
1188         $message = $this->_searchForMessageBySubject(Tinebase_Core::filterInputForDatabase($subject));
1189         $fullMessage = $this->_json->getMessage($message['id']);
1190
1191         $this->assertContains('multipart/encrypted', $fullMessage['headers']['content-type']);
1192         $this->assertContains('protocol="application/pgp-encrypted"', $fullMessage['headers']['content-type']);
1193         $this->assertCount(2, $fullMessage['structure']['parts']);
1194         $this->assertEquals('application/pgp-encrypted', $fullMessage['structure']['parts'][1]['contentType']);
1195         $this->assertEquals('application/octet-stream', $fullMessage['structure']['parts'][2]['contentType']);
1196
1197         return $fullMessage;
1198     }
1199
1200     /**
1201      * testMessagePGPMime
1202      *
1203      * - prepare amored part of PGP MIME structure
1204      */
1205     public function testMessagePGPMime()
1206     {
1207         $fullMessage = $this->testSendMailveopeAPIMessage();
1208
1209         $this->assertEquals('application/pgp-encrypted', $fullMessage['preparedParts'][0]['contentType']);
1210         $this->assertContains('-----BEGIN PGP MESSAGE-----', $fullMessage['preparedParts'][0]['preparedData']);
1211     }
1212
1213     /*********************** sieve tests ****************************/
1214     
1215     /**
1216      * set and get vacation sieve script
1217      *
1218      * @see 0007768: Sieve - Vacation notify frequency not being set (Cyrus)
1219      */
1220     public function testGetSetVacation()
1221     {
1222         $vacationData = $this->_getVacationData();
1223         $this->_sieveTestHelper($vacationData);
1224         
1225         // check if script was activated
1226         $activeScriptName = Felamimail_Controller_Sieve::getInstance()->getActiveScriptName($this->_account->getId());
1227         $this->assertEquals($this->_testSieveScriptName, $activeScriptName);
1228         $updatedAccount = Felamimail_Controller_Account::getInstance()->get($this->_account->getId());
1229         $this->assertTrue((bool) $updatedAccount->sieve_vacation_active);
1230         
1231         $result = $this->_json->getVacation($this->_account->getId());
1232
1233         $this->assertEquals($this->_account->email, $result['addresses'][0]);
1234         
1235         $sieveBackend = Felamimail_Backend_SieveFactory::factory($this->_account->getId());
1236         if (preg_match('/dbmail/i', $sieveBackend->getImplementation())) {
1237             $translate = Tinebase_Translation::getTranslation('Felamimail');
1238             $vacationData['subject'] = sprintf($translate->_('Out of Office reply from %1$s'), Tinebase_Core::getUser()->accountFullName);
1239         }
1240         
1241         foreach (array('reason', 'enabled', 'subject', 'from', 'days') as $field) {
1242             $this->assertEquals($vacationData[$field], $result[$field], 'vacation data mismatch: ' . $field);
1243         }
1244     }
1245     
1246     /**
1247      * get vacation data
1248      *
1249      * @return array
1250      */
1251     protected function _getVacationData()
1252     {
1253         return array(
1254             'id'                    => $this->_account->getId(),
1255             'subject'               => 'unittest vacation subject',
1256             'from'                  => $this->_account->from . ' <' . $this->_account->email . '>',
1257             'days'                  => 3,
1258             'enabled'               => TRUE,
1259             'reason'                => 'unittest vacation message<br /><br />signature',
1260             'mime'                  => NULL,
1261         );
1262     }
1263     
1264     /**
1265      * test mime vacation sieve script
1266      */
1267     public function testMimeVacation()
1268     {
1269         $vacationData = $this->_getVacationData();
1270         $vacationData['reason'] = "\n<html><body><h1>unittest vacation&nbsp;message</h1></body></html>";
1271         
1272         $_sieveBackend = Felamimail_Backend_SieveFactory::factory($this->_account->getId());
1273         if (! in_array('mime', $_sieveBackend->capability())) {
1274             $vacationData['mime'] = 'text/html';
1275         }
1276         
1277         $this->_sieveTestHelper($vacationData, TRUE);
1278     }
1279     
1280     /**
1281      * test get/set of rules sieve script
1282      */
1283     public function testGetSetRules()
1284     {
1285         $ruleData = $this->_getRuleData();
1286         
1287         $this->_sieveTestHelper($ruleData);
1288         
1289         // check getRules
1290         $result = $this->_json->getRules($this->_account->getId());
1291         $this->assertEquals($result['totalcount'], count($ruleData));
1292         
1293         // check by sending mail
1294         $messageData = $this->_getMessageData('', 'viagra');
1295         $returned = $this->_json->saveMessage($messageData);
1296         $this->_foldersToClear = array('INBOX', $this->_testFolderName);
1297         // check if message is in test folder
1298         $message = $this->_searchForMessageBySubject($messageData['subject'], $this->_testFolderName);
1299     }
1300     
1301     /**
1302      * testRemoveRules
1303      *
1304      * @see 0006490: can not delete single filter rule
1305      */
1306     public function testRemoveRules()
1307     {
1308         $this->testGetSetRules();
1309         $this->_json->saveRules($this->_account->getId(), array());
1310         
1311         $result = $this->_json->getRules($this->_account->getId());
1312         $this->assertEquals(0, $result['totalcount'], 'found rules: ' . print_r($result, TRUE));
1313     }
1314     
1315     /**
1316      * get sieve rule data
1317      *
1318      * @return array
1319      */
1320     protected function _getRuleData()
1321     {
1322         return array(array(
1323             'id'            => 1,
1324             'action_type'   => Felamimail_Sieve_Rule_Action::FILEINTO,
1325             'action_argument' => $this->_testFolderName,
1326             'conjunction'  => 'allof',
1327             'conditions'    => array(array(
1328                 'test'          => Felamimail_Sieve_Rule_Condition::TEST_ADDRESS,
1329                 'comperator'    => Felamimail_Sieve_Rule_Condition::COMPERATOR_CONTAINS,
1330                 'header'        => 'From',
1331                 'key'           => '"abcd" <info@example.org>',
1332             )),
1333             'enabled'       => 1,
1334         ), array(
1335             'id'            => 2,
1336             'action_type'   => Felamimail_Sieve_Rule_Action::FILEINTO,
1337             'action_argument' => $this->_testFolderName,
1338             'conjunction'  => 'allof',
1339             'conditions'    => array(array(
1340                 'test'          => Felamimail_Sieve_Rule_Condition::TEST_ADDRESS,
1341                 'comperator'    => Felamimail_Sieve_Rule_Condition::COMPERATOR_CONTAINS,
1342                 'header'        => 'From',
1343                 'key'           => 'info@example.org',
1344             )),
1345             'enabled'       => 0,
1346         ), array(
1347             'id'            => 3,
1348             'action_type'   => Felamimail_Sieve_Rule_Action::FILEINTO,
1349             'action_argument' => $this->_testFolderName,
1350             'conjunction'  => 'allof',
1351             'conditions'    => array(array(
1352                 'test'          => Felamimail_Sieve_Rule_Condition::TEST_HEADER,
1353                 'comperator'    => Felamimail_Sieve_Rule_Condition::COMPERATOR_REGEX,
1354                 'header'        => 'subject',
1355                 'key'           => '[vV]iagra|cyalis',
1356             )),
1357             'enabled'       => 1,
1358         ));
1359     }
1360     
1361     /**
1362      * test to set a forward rule to this accounts email address
1363      * -> should throw exception to prevent mail cycling
1364      */
1365     public function testSetForwardRuleToSelf()
1366     {
1367         $ruleData = array(array(
1368             'id'            => 1,
1369             'action_type'   => Felamimail_Sieve_Rule_Action::REDIRECT,
1370             'action_argument' => $this->_account->email,
1371             'conjunction'     => 'allof',
1372             'conditions'    => array(array(
1373                 'test'          => Felamimail_Sieve_Rule_Condition::TEST_ADDRESS,
1374                 'comperator'    => Felamimail_Sieve_Rule_Condition::COMPERATOR_CONTAINS,
1375                 'header'        => 'From',
1376                 'key'           => 'info@example.org',
1377             )),
1378             'enabled'       => 1,
1379         ));
1380         
1381         try {
1382             $this->_sieveTestHelper($ruleData);
1383             $this->assertTrue(FALSE, 'it is not allowed to set own email address for redirect!');
1384         } catch (Felamimail_Exception_Sieve $e) {
1385             $this->assertTrue(TRUE);
1386         }
1387
1388         // this should work
1389         $ruleData[0]['enabled'] = 0;
1390         $this->_sieveTestHelper($ruleData);
1391     }
1392     
1393     /**
1394      * testGetVacationTemplates
1395      *
1396      * @return array
1397      */
1398     public function testGetVacationTemplates()
1399     {
1400         $this->markTestSkipped('0010194: fix felamimail webdav tests');
1401         
1402         $this->_addVacationTemplateFile();
1403         $result = $this->_json->getVacationMessageTemplates();
1404         
1405         $this->assertTrue($result['totalcount'] > 0, 'no templates found');
1406         $found = FALSE;
1407         foreach ($result['results'] as $template) {
1408             if ($template['name'] === $this->_sieveVacationTemplateFile) {
1409                 $found = TRUE;
1410                 break;
1411             }
1412         }
1413         
1414         $this->assertTrue($found, 'wrong templates: ' . print_r($result['results'], TRUE));
1415         
1416         return $template;
1417     }
1418     
1419     /**
1420      * add vacation template file to vfs
1421      */
1422     protected function _addVacationTemplateFile()
1423     {
1424         $webdavRoot = new DAV\ObjectTree(new Tinebase_WebDav_Root());
1425         $path = '/webdav/Felamimail/shared/Vacation Templates';
1426         $node = $webdavRoot->getNodeForPath($path);
1427         $this->_pathsToDelete[] = $path . '/' . $this->_sieveVacationTemplateFile;
1428         $node->createFile($this->_sieveVacationTemplateFile, fopen(dirname(__FILE__) . '/../files/' . $this->_sieveVacationTemplateFile, 'r'));
1429     }
1430     
1431     /**
1432      * testGetVacationMessage
1433      */
1434     public function testGetVacationMessage()
1435     {
1436         $this->markTestSkipped('0010194: fix felamimail webdav tests');
1437         
1438         $result = $this->_getVacationMessageWithTemplate();
1439         $sclever = Tinebase_User::getInstance()->getFullUserByLoginName('sclever');
1440         $pwulf = Tinebase_User::getInstance()->getFullUserByLoginName('pwulf');
1441         $this->assertEquals("Ich bin vom 18.04.2012 bis zum 20.04.2012 im Urlaub. Bitte kontaktieren Sie<br /> Paul Wulf (" .
1442             $pwulf->accountEmailAddress . ") oder Susan Clever (" .
1443             $sclever->accountEmailAddress . ").<br /><br />I am on vacation until Apr 20, 2012. Please contact Paul Wulf<br />(" .
1444             $pwulf->accountEmailAddress . ") or Susan Clever (" .
1445             $sclever->accountEmailAddress . ") instead.<br /><br />" .
1446             Addressbook_Controller_Contact::getInstance()->getContactByUserId(Tinebase_Core::getUser()->getId())->n_fn, $result['message']);
1447     }
1448     
1449     /**
1450      * get vacation message with template
1451      *
1452      * @return array
1453      */
1454     protected function _getVacationMessageWithTemplate()
1455     {
1456         $template = $this->testGetVacationTemplates();
1457         $sclever = Tinebase_User::getInstance()->getFullUserByLoginName('sclever');
1458         $result = $this->_json->getVacationMessage(array(
1459             'start_date' => '2012-04-18',
1460             'end_date'   => '2012-04-20',
1461             'contact_ids' => array(
1462                 Tinebase_User::getInstance()->getFullUserByLoginName('pwulf')->contact_id,
1463                 $sclever->contact_id,
1464             ),
1465             'template_id' => $template['id'],
1466             'signature' => $this->_account->signature
1467         ));
1468         
1469         return $result;
1470     }
1471     
1472     /**
1473      * testGetVacationWithSignature
1474      *
1475      * @see 0006866: check signature linebreaks in vacation message from template
1476      */
1477     public function testGetVacationWithSignature()
1478     {
1479         $this->markTestSkipped('0010194: fix felamimail webdav tests');
1480         
1481         $this->_sieveVacationTemplateFile = 'vacation_template_sig.tpl';
1482         
1483         // set signature with <br> + linebreaks
1484         $this->_account->signature = "llalala<br>\nxyz<br>\nblubb<br>";
1485         
1486         $result = $this->_getVacationMessageWithTemplate();
1487         $this->assertContains('-- <br />llalala<br />xyz<br />blubb<br />', $result['message'], 'wrong linebreaks or missing signature');
1488     }
1489     
1490     /**
1491     * testSetVacationWithStartAndEndDate
1492     *
1493     * @see 0006266: automatic deactivation of vacation message
1494     */
1495     public function testSetVacationWithStartAndEndDate()
1496     {
1497         $vacationData = $this->_getVacationData();
1498         $vacationData['start_date'] = '2012-04-18';
1499         $vacationData['end_date'] = '2012-04-20';
1500         $result = $this->_sieveTestHelper($vacationData);
1501         
1502         $this->assertContains($vacationData['start_date'], $result['start_date']);
1503         $this->assertContains($vacationData['end_date'], $result['end_date']);
1504     }
1505     
1506     /**
1507      * testSieveRulesOrder
1508      *
1509      * @see 0007240: order of sieve rules changes when vacation message is saved
1510      */
1511     public function testSieveRulesOrder()
1512     {
1513         $this->_setTestScriptname();
1514         
1515         // disable vacation first
1516         $this->_setDisabledVacation();
1517         
1518         $sieveBackend = Felamimail_Backend_SieveFactory::factory($this->_account->getId());
1519         
1520         $ruleData = $this->_getRuleData();
1521         $ruleData[0]['id'] = $ruleData[2]['id'];
1522         $ruleData[2]['id'] = 11;
1523         $resultSet = $this->_json->saveRules($this->_account->getId(), $ruleData);
1524         $sieveScriptRules = $sieveBackend->getScript($this->_testSieveScriptName);
1525         
1526         $this->_setDisabledVacation();
1527         $sieveScriptVacation = $sieveBackend->getScript($this->_testSieveScriptName);
1528         
1529         // compare sieve scripts
1530         $this->assertContains($sieveScriptRules, $sieveScriptVacation, 'rule order changed');
1531     }
1532     
1533     /**
1534      * use another name for test sieve script
1535      */
1536     protected function _setTestScriptname()
1537     {
1538         $this->_oldActiveSieveScriptName = Felamimail_Controller_Sieve::getInstance()->getActiveScriptName($this->_account->getId());
1539         $this->_testSieveScriptName = 'Felamimail_Unittest';
1540         Felamimail_Controller_Sieve::getInstance()->setScriptName($this->_testSieveScriptName);
1541     }
1542     
1543     /**
1544      * set disabled vacation message
1545      */
1546     protected function _setDisabledVacation()
1547     {
1548         $vacationData = $this->_getVacationData();
1549         $vacationData['enabled'] = FALSE;
1550         $resultSet = $this->_json->saveVacation($vacationData);
1551     }
1552     
1553     /**
1554      * get folder filter
1555      *
1556      * @return array
1557      */
1558     protected function _getFolderFilter()
1559     {
1560         return array(array(
1561             'field' => 'globalname', 'operator' => 'equals', 'value' => ''
1562         ));
1563     }
1564
1565     /**
1566      * get message filter
1567      *
1568      * @param string $_folderId
1569      * @return array
1570      */
1571     protected function _getMessageFilter($_folderId)
1572     {
1573         $result = array(array(
1574             'field' => 'folder_id', 'operator' => 'equals', 'value' => $_folderId
1575         ));
1576         
1577         return $result;
1578     }
1579     
1580     /**
1581      * get mailbox
1582      *
1583      * @param string $name
1584      * @param boolean $createFolder
1585      * @return Felamimail_Model_Folder|NULL
1586      */
1587     protected function _getFolder($name, $createFolder = TRUE)
1588     {
1589         Felamimail_Controller_Cache_Folder::getInstance()->update($this->_account->getId());
1590         try {
1591             $folder = Felamimail_Controller_Folder::getInstance()->getByBackendAndGlobalName($this->_account->getId(), $name);
1592         } catch (Tinebase_Exception_NotFound $tenf) {
1593             $folder = ($createFolder) ? Felamimail_Controller_Folder::getInstance()->create($this->_account, $name) : NULL;
1594         }
1595         
1596         return $folder;
1597     }
1598
1599     /**
1600      * get message data
1601      *
1602      * @return array
1603      */
1604     protected function _getMessageData($_emailFrom = '', $_subject = 'test')
1605     {
1606         return array(
1607             'account_id'    => $this->_account->getId(),
1608             'subject'       => $_subject,
1609             'to'            => array(Tinebase_Core::getUser()->accountEmailAddress),
1610             'body'          => 'aaaaaä <br>',
1611             'headers'       => array('X-Tine20TestMessage' => 'jsontest'),
1612             'from_email'    => $_emailFrom,
1613             'content_type'  => Felamimail_Model_Message::CONTENT_TYPE_HTML,
1614         );
1615     }
1616
1617     /**
1618      * send message and return message array
1619      *
1620      * @param string $folderName
1621      * @param array $addtionalHeaders
1622      * @return array
1623      */
1624     protected function _sendMessage($folderName = 'INBOX', $addtionalHeaders = array())
1625     {
1626         $messageToSend = $this->_getMessageData();
1627         $messageToSend['headers'] = array_merge($messageToSend['headers'], $addtionalHeaders);
1628         $returned = $this->_json->saveMessage($messageToSend);
1629         $this->_foldersToClear = array('INBOX', $this->_account->sent_folder);
1630
1631         // sleep for 2 secs because mailserver may be slower than expected
1632         sleep(2);
1633         
1634         $result = $this->_getMessages($folderName);
1635         $message = $this->_getMessageFromSearchResult($result, $messageToSend['subject']);
1636         
1637         $this->assertTrue(! empty($message), 'Sent message not found.');
1638         
1639         return $message;
1640     }
1641     
1642     /**
1643      * returns message array from result
1644      *
1645      * @param array $_result
1646      * @param string $_subject
1647      * @return array
1648      */
1649     protected function _getMessageFromSearchResult($_result, $_subject)
1650     {
1651         $message = array();
1652         foreach ($_result['results'] as $mail) {
1653             if ($mail['subject'] == $_subject) {
1654                 $message = $mail;
1655             }
1656         }
1657         
1658         return $message;
1659     }
1660     
1661     /**
1662      * get messages from folder
1663      *
1664      * @param string $_folderName
1665      * @return array
1666      */
1667     protected function _getMessages($_folderName = 'INBOX')
1668     {
1669         $folder = $this->_getFolder($_folderName);
1670         $filter = $this->_getMessageFilter($folder->getId());
1671         // update cache
1672         $folder = Felamimail_Controller_Cache_Message::getInstance()->updateCache($folder, 10, 1);
1673         $i = 0;
1674         while ($folder->cache_status != Felamimail_Model_Folder::CACHE_STATUS_COMPLETE && $i < 10) {
1675             $folder = Felamimail_Controller_Cache_Message::getInstance()->updateCache($folder, 10);
1676             $i++;
1677         }
1678         $result = $this->_json->searchMessages($filter, '');
1679         //print_r($result);
1680         
1681         return $result;
1682     }
1683     
1684     /**
1685      * search for message defined by subject in folder
1686      *
1687      * @param string $_subject
1688      * @param string $_folderName
1689      * @return string message data
1690      */
1691     protected function _searchForMessageBySubject($_subject, $_folderName = 'INBOX')
1692     {
1693         $result = $this->_getMessages($_folderName);
1694         
1695         $message = array();
1696         foreach ($result['results'] as $mail) {
1697             if ($mail['subject'] == $_subject) {
1698                 $message = $mail;
1699             }
1700         }
1701         $this->assertGreaterThan(0, $result['totalcount'], 'folder is empty');
1702         $this->assertTrue(! empty($message), 'Message not found');
1703         
1704         return $message;
1705     }
1706     
1707     /**
1708      * sieve test helper
1709      *
1710      * @param array $_sieveData
1711      * @return array
1712      */
1713     protected function _sieveTestHelper($_sieveData, $_isMime = FALSE)
1714     {
1715         $this->_setTestScriptname();
1716         
1717         // check which save fn to use
1718         if ((isset($_sieveData['reason']) || array_key_exists('reason', $_sieveData))) {
1719             $resultSet = $this->_json->saveVacation($_sieveData);
1720             $this->assertEquals($this->_account->email, $resultSet['addresses'][0]);
1721             
1722             $_sieveBackend = Felamimail_Backend_SieveFactory::factory($this->_account->getId());
1723             
1724             if (preg_match('/dbmail/i', $_sieveBackend->getImplementation())) {
1725                 $translate = Tinebase_Translation::getTranslation('Felamimail');
1726                 $this->assertEquals(sprintf(
1727                     $translate->_('Out of Office reply from %1$s'), Tinebase_Core::getUser()->accountFullName),
1728                     $resultSet['subject']
1729                 );
1730             } else {
1731                 $this->assertEquals($_sieveData['subject'], $resultSet['subject']);
1732             }
1733             
1734             if ($_isMime) {
1735                 $this->assertEquals(html_entity_decode('unittest vacation&nbsp;message', ENT_NOQUOTES, 'UTF-8'), $resultSet['reason']);
1736             } else {
1737                 $this->assertEquals($_sieveData['reason'], $resultSet['reason']);
1738             }
1739             
1740         } else if ((isset($_sieveData[0]['action_type']) || array_key_exists('action_type', $_sieveData[0]))) {
1741             $resultSet = $this->_json->saveRules($this->_account->getId(), $_sieveData);
1742             $this->assertEquals($_sieveData, $resultSet);
1743         }
1744         
1745         return $resultSet;
1746     }
1747
1748     /**
1749      * search preferences by application felamimail
1750      *
1751      */
1752     public function testSearchFelamimailPreferences()
1753     {
1754         // search prefs
1755         $result = $this->_frontend->searchPreferencesForApplication('Felamimail', '');
1756         
1757         // check results
1758         $this->assertTrue(isset($result['results']));
1759         $this->assertGreaterThan(0, $result['totalcount']);
1760     }
1761     
1762     /**
1763      * testGetRegistryData
1764      *
1765      * @see 0010251: do not send unused config data to client
1766      */
1767     public function testGetRegistryData()
1768     {
1769         $regData = $this->_json->getRegistryData();
1770
1771         $this->assertFalse(isset($regData['defaults']));
1772         $supportedFlags = Felamimail_Config::getInstance()->featureEnabled(Felamimail_Config::FEATURE_TINE20_FLAG)
1773             ? 6
1774             : 5;
1775         $this->assertEquals($supportedFlags, $regData['supportedFlags']['totalcount']);
1776     }
1777 }