2015-10-30 15:10:08 +03:00
< ? php
/**
* @ author Roeland Jago Douma < rullzer @ owncloud . com >
*
* @ copyright Copyright ( c ) 2015 , ownCloud , Inc .
* @ license AGPL - 3.0
*
* This code is free software : you can redistribute it and / or modify
* it under the terms of the GNU Affero General Public License , version 3 ,
* as published by the Free Software Foundation .
*
* This program is distributed in the hope that it will be useful ,
* but WITHOUT ANY WARRANTY ; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the
* GNU Affero General Public License for more details .
*
* You should have received a copy of the GNU Affero General Public License , version 3 ,
* along with this program . If not , see < http :// www . gnu . org / licenses />
*
*/
2019-11-22 22:52:10 +03:00
2015-10-30 15:10:08 +03:00
namespace Test\Share20 ;
2016-09-02 12:24:43 +03:00
use OC\Files\Mount\MoveableMount ;
2016-06-27 11:46:39 +03:00
use OC\HintException ;
2016-11-01 14:35:50 +03:00
use OC\Share20\DefaultShareProvider ;
2019-11-22 22:52:10 +03:00
use OC\Share20\Exception ;
use OC\Share20\Manager ;
use OC\Share20\Share ;
2019-11-19 21:18:00 +03:00
use OCP\EventDispatcher\Event ;
2019-12-12 23:38:52 +03:00
use OCP\EventDispatcher\IEventDispatcher ;
2016-09-02 12:24:43 +03:00
use OCP\Files\File ;
use OCP\Files\Folder ;
2016-02-04 14:51:23 +03:00
use OCP\Files\IRootFolder ;
2019-11-22 22:52:10 +03:00
use OCP\Files\Mount\IMountManager ;
2016-09-02 12:24:43 +03:00
use OCP\Files\Mount\IMountPoint ;
use OCP\Files\Node ;
use OCP\Files\Storage ;
2019-11-22 22:52:10 +03:00
use OCP\IConfig ;
2016-09-02 12:24:43 +03:00
use OCP\IGroup ;
2019-11-22 22:52:10 +03:00
use OCP\IGroupManager ;
use OCP\IL10N ;
use OCP\ILogger ;
2016-11-01 14:35:50 +03:00
use OCP\IServerContainer ;
2017-07-27 00:53:07 +03:00
use OCP\IURLGenerator ;
2016-09-02 12:24:43 +03:00
use OCP\IUser ;
2016-02-02 23:02:09 +03:00
use OCP\IUserManager ;
2017-09-08 11:34:19 +03:00
use OCP\L10N\IFactory ;
2017-07-27 00:53:07 +03:00
use OCP\Mail\IMailer ;
2019-11-19 21:18:00 +03:00
use OCP\Security\Events\ValidatePasswordPolicyEvent ;
2019-11-22 22:52:10 +03:00
use OCP\Security\IHasher ;
use OCP\Security\ISecureRandom ;
2016-02-05 14:59:46 +03:00
use OCP\Share\Exceptions\ShareNotFound ;
2016-01-27 14:13:53 +03:00
use OCP\Share\IProviderFactory ;
use OCP\Share\IShare ;
use OCP\Share\IShareProvider ;
2019-11-19 21:18:00 +03:00
use PHPUnit\Framework\MockObject\MockBuilder ;
use PHPUnit\Framework\MockObject\MockObject ;
2019-05-28 20:46:36 +03:00
use Symfony\Component\EventDispatcher\EventDispatcherInterface ;
2016-06-27 11:46:39 +03:00
use Symfony\Component\EventDispatcher\GenericEvent ;
2015-10-30 15:10:08 +03:00
2015-12-15 11:54:12 +03:00
/**
* Class ManagerTest
*
* @ package Test\Share20
* @ group DB
*/
2015-10-30 15:10:08 +03:00
class ManagerTest extends \Test\TestCase {
/** @var Manager */
protected $manager ;
2019-11-19 21:18:00 +03:00
/** @var ILogger|MockObject */
2015-10-30 15:10:08 +03:00
protected $logger ;
2019-11-19 21:18:00 +03:00
/** @var IConfig|MockObject */
2015-12-15 11:54:12 +03:00
protected $config ;
2019-11-19 21:18:00 +03:00
/** @var ISecureRandom|MockObject */
2015-12-15 11:54:12 +03:00
protected $secureRandom ;
2019-11-19 21:18:00 +03:00
/** @var IHasher|MockObject */
2015-12-15 11:54:12 +03:00
protected $hasher ;
2019-11-19 21:18:00 +03:00
/** @var IShareProvider|MockObject */
2015-10-30 15:10:08 +03:00
protected $defaultProvider ;
2019-11-19 21:18:00 +03:00
/** @var IMountManager|MockObject */
2015-12-15 11:54:12 +03:00
protected $mountManager ;
2019-11-19 21:18:00 +03:00
/** @var IGroupManager|MockObject */
2015-12-15 11:54:12 +03:00
protected $groupManager ;
2019-11-19 21:18:00 +03:00
/** @var IL10N|MockObject */
2016-01-05 14:50:00 +03:00
protected $l ;
2019-11-19 21:18:00 +03:00
/** @var IFactory|MockObject */
2017-09-08 11:34:19 +03:00
protected $l10nFactory ;
2016-01-13 16:21:55 +03:00
/** @var DummyFactory */
2016-01-11 12:30:03 +03:00
protected $factory ;
2019-11-19 21:18:00 +03:00
/** @var IUserManager|MockObject */
2016-02-02 23:02:09 +03:00
protected $userManager ;
2019-11-19 21:18:00 +03:00
/** @var IRootFolder | MockObject */
2016-02-04 14:51:23 +03:00
protected $rootFolder ;
2019-11-19 21:18:00 +03:00
/** @var EventDispatcherInterface | MockObject */
2016-06-24 18:53:37 +03:00
protected $eventDispatcher ;
2019-12-12 23:38:52 +03:00
/** @var IEventDispatcher|MockObject */
protected $dispatcher ;
2019-11-19 21:18:00 +03:00
/** @var IMailer|MockObject */
2017-07-27 00:53:07 +03:00
protected $mailer ;
2019-11-19 21:18:00 +03:00
/** @var IURLGenerator|MockObject */
2017-07-27 00:53:07 +03:00
protected $urlGenerator ;
2019-11-19 21:18:00 +03:00
/** @var \OC_Defaults|MockObject */
2017-07-27 00:53:07 +03:00
protected $defaults ;
2016-02-02 23:02:09 +03:00
2019-11-27 17:27:18 +03:00
protected function setUp () : void {
2016-09-02 12:24:43 +03:00
$this -> logger = $this -> createMock ( ILogger :: class );
$this -> config = $this -> createMock ( IConfig :: class );
$this -> secureRandom = $this -> createMock ( ISecureRandom :: class );
$this -> hasher = $this -> createMock ( IHasher :: class );
$this -> mountManager = $this -> createMock ( IMountManager :: class );
$this -> groupManager = $this -> createMock ( IGroupManager :: class );
$this -> userManager = $this -> createMock ( IUserManager :: class );
$this -> rootFolder = $this -> createMock ( IRootFolder :: class );
2019-05-28 20:46:36 +03:00
$this -> eventDispatcher = $this -> createMock ( EventDispatcherInterface :: class );
2017-07-27 00:53:07 +03:00
$this -> mailer = $this -> createMock ( IMailer :: class );
$this -> urlGenerator = $this -> createMock ( IURLGenerator :: class );
$this -> defaults = $this -> createMock ( \OC_Defaults :: class );
2019-12-12 23:38:52 +03:00
$this -> dispatcher = $this -> createMock ( IEventDispatcher :: class );
2016-09-02 12:24:43 +03:00
2017-09-08 11:34:19 +03:00
$this -> l10nFactory = $this -> createMock ( IFactory :: class );
2016-09-02 12:24:43 +03:00
$this -> l = $this -> createMock ( IL10N :: class );
2016-01-05 14:50:00 +03:00
$this -> l -> method ( 't' )
2020-04-09 14:53:40 +03:00
-> willReturnCallback ( function ( $text , $parameters = []) {
2020-04-09 10:22:29 +03:00
return vsprintf ( $text , $parameters );
});
2016-01-05 14:50:00 +03:00
2016-01-20 10:30:37 +03:00
$this -> factory = new DummyFactory ( \OC :: $server );
2016-01-11 12:30:03 +03:00
2015-10-30 15:10:08 +03:00
$this -> manager = new Manager (
$this -> logger ,
2015-12-15 11:54:12 +03:00
$this -> config ,
$this -> secureRandom ,
$this -> hasher ,
$this -> mountManager ,
2016-01-05 14:50:00 +03:00
$this -> groupManager ,
2016-01-11 12:30:03 +03:00
$this -> l ,
2017-09-08 11:34:19 +03:00
$this -> l10nFactory ,
2016-02-02 23:02:09 +03:00
$this -> factory ,
2016-02-04 14:51:23 +03:00
$this -> userManager ,
2016-06-24 18:53:37 +03:00
$this -> rootFolder ,
2017-07-27 00:53:07 +03:00
$this -> eventDispatcher ,
$this -> mailer ,
$this -> urlGenerator ,
2019-12-12 23:38:52 +03:00
$this -> defaults ,
$this -> dispatcher
2015-10-30 15:10:08 +03:00
);
2016-01-11 12:30:03 +03:00
2016-11-01 14:35:50 +03:00
$this -> defaultProvider = $this -> createMock ( DefaultShareProvider :: class );
2016-01-13 15:02:23 +03:00
$this -> defaultProvider -> method ( 'identifier' ) -> willReturn ( 'default' );
2016-01-13 16:21:55 +03:00
$this -> factory -> setProvider ( $this -> defaultProvider );
2016-01-11 12:30:03 +03:00
}
/**
2019-11-19 21:18:00 +03:00
* @ return MockBuilder
2016-01-11 12:30:03 +03:00
*/
private function createManagerMock () {
return $this -> getMockBuilder ( '\OC\Share20\Manager' )
-> setConstructorArgs ([
$this -> logger ,
$this -> config ,
$this -> secureRandom ,
$this -> hasher ,
$this -> mountManager ,
$this -> groupManager ,
$this -> l ,
2017-09-08 11:34:19 +03:00
$this -> l10nFactory ,
2016-02-02 23:02:09 +03:00
$this -> factory ,
2016-02-04 14:51:23 +03:00
$this -> userManager ,
2016-06-24 18:53:37 +03:00
$this -> rootFolder ,
2017-07-27 00:53:07 +03:00
$this -> eventDispatcher ,
$this -> mailer ,
$this -> urlGenerator ,
2019-12-12 23:38:52 +03:00
$this -> defaults ,
$this -> dispatcher
2016-01-11 12:30:03 +03:00
]);
}
2019-12-12 23:38:52 +03:00
2015-10-30 15:10:08 +03:00
public function testDeleteNoShareId () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \InvalidArgumentException :: class );
2016-02-11 13:21:12 +03:00
$share = $this -> manager -> newShare ();
2015-10-30 15:10:08 +03:00
$this -> manager -> deleteShare ( $share );
}
2015-11-10 16:14:49 +03:00
public function dataTestDelete () {
2016-09-02 12:24:43 +03:00
$user = $this -> createMock ( IUser :: class );
2015-11-10 16:14:49 +03:00
$user -> method ( 'getUID' ) -> willReturn ( 'sharedWithUser' );
2016-09-02 12:24:43 +03:00
$group = $this -> createMock ( IGroup :: class );
2015-11-10 16:14:49 +03:00
$group -> method ( 'getGID' ) -> willReturn ( 'sharedWithGroup' );
2016-06-24 18:53:37 +03:00
2015-11-10 16:14:49 +03:00
return [
2016-02-02 23:02:09 +03:00
[ \OCP\Share :: SHARE_TYPE_USER , 'sharedWithUser' ],
[ \OCP\Share :: SHARE_TYPE_GROUP , 'sharedWithGroup' ],
[ \OCP\Share :: SHARE_TYPE_LINK , '' ],
[ \OCP\Share :: SHARE_TYPE_REMOTE , 'foo@bar.com' ],
2015-11-10 16:14:49 +03:00
];
}
/**
* @ dataProvider dataTestDelete
*/
2016-02-02 23:02:09 +03:00
public function testDelete ( $shareType , $sharedWith ) {
2016-01-11 12:30:03 +03:00
$manager = $this -> createManagerMock ()
2015-11-10 16:14:49 +03:00
-> setMethods ([ 'getShareById' , 'deleteChildren' ])
-> getMock ();
2016-09-02 12:24:43 +03:00
$path = $this -> createMock ( File :: class );
2015-11-10 16:14:49 +03:00
$path -> method ( 'getId' ) -> willReturn ( 1 );
2016-01-27 22:51:26 +03:00
$share = $this -> manager -> newShare ();
$share -> setId ( 42 )
-> setProviderId ( 'prov' )
-> setShareType ( $shareType )
-> setSharedWith ( $sharedWith )
2016-02-02 23:02:09 +03:00
-> setSharedBy ( 'sharedBy' )
2016-01-27 22:51:26 +03:00
-> setNode ( $path )
-> setTarget ( 'myTarget' );
2015-11-10 16:14:49 +03:00
$manager -> expects ( $this -> once ()) -> method ( 'deleteChildren' ) -> with ( $share );
2015-10-30 15:10:08 +03:00
2016-01-13 16:21:55 +03:00
$this -> defaultProvider
2015-10-30 15:10:08 +03:00
-> expects ( $this -> once ())
-> method ( 'delete' )
-> with ( $share );
2017-03-14 21:18:20 +03:00
$this -> eventDispatcher -> expects ( $this -> at ( 0 ))
-> method ( 'dispatch' )
-> with (
'OCP\Share::preUnshare' ,
2020-04-09 14:53:40 +03:00
$this -> callBack ( function ( GenericEvent $e ) use ( $share ) {
2017-03-14 21:18:20 +03:00
return $e -> getSubject () === $share ;
})
);
$this -> eventDispatcher -> expects ( $this -> at ( 1 ))
-> method ( 'dispatch' )
-> with (
'OCP\Share::postUnshare' ,
2020-04-09 14:53:40 +03:00
$this -> callBack ( function ( GenericEvent $e ) use ( $share ) {
2017-03-14 21:18:20 +03:00
return $e -> getSubject () === $share &&
$e -> getArgument ( 'deletedShares' ) === [ $share ];
})
);
2016-02-04 16:28:09 +03:00
$manager -> deleteShare ( $share );
}
public function testDeleteLazyShare () {
$manager = $this -> createManagerMock ()
-> setMethods ([ 'getShareById' , 'deleteChildren' ])
-> getMock ();
$share = $this -> manager -> newShare ();
$share -> setId ( 42 )
-> setProviderId ( 'prov' )
-> setShareType ( \OCP\Share :: SHARE_TYPE_USER )
-> setSharedWith ( 'sharedWith' )
-> setSharedBy ( 'sharedBy' )
-> setShareOwner ( 'shareOwner' )
-> setTarget ( 'myTarget' )
-> setNodeId ( 1 )
-> setNodeType ( 'file' );
$this -> rootFolder -> expects ( $this -> never ()) -> method ( $this -> anything ());
$manager -> expects ( $this -> once ()) -> method ( 'deleteChildren' ) -> with ( $share );
$this -> defaultProvider
-> expects ( $this -> once ())
-> method ( 'delete' )
-> with ( $share );
2017-03-14 21:18:20 +03:00
$this -> eventDispatcher -> expects ( $this -> at ( 0 ))
-> method ( 'dispatch' )
-> with (
'OCP\Share::preUnshare' ,
2020-04-09 14:53:40 +03:00
$this -> callBack ( function ( GenericEvent $e ) use ( $share ) {
2017-03-14 21:18:20 +03:00
return $e -> getSubject () === $share ;
})
);
$this -> eventDispatcher -> expects ( $this -> at ( 1 ))
-> method ( 'dispatch' )
-> with (
'OCP\Share::postUnshare' ,
2020-04-09 14:53:40 +03:00
$this -> callBack ( function ( GenericEvent $e ) use ( $share ) {
2017-03-14 21:18:20 +03:00
return $e -> getSubject () === $share &&
$e -> getArgument ( 'deletedShares' ) === [ $share ];
})
);
2015-11-10 16:14:49 +03:00
$manager -> deleteShare ( $share );
}
public function testDeleteNested () {
2016-01-11 12:30:03 +03:00
$manager = $this -> createManagerMock ()
2015-11-10 16:14:49 +03:00
-> setMethods ([ 'getShareById' ])
-> getMock ();
2016-09-02 12:24:43 +03:00
$path = $this -> createMock ( File :: class );
2015-11-10 16:14:49 +03:00
$path -> method ( 'getId' ) -> willReturn ( 1 );
2016-01-27 22:51:26 +03:00
$share1 = $this -> manager -> newShare ();
$share1 -> setId ( 42 )
-> setProviderId ( 'prov' )
-> setShareType ( \OCP\Share :: SHARE_TYPE_USER )
2016-02-02 23:02:09 +03:00
-> setSharedWith ( 'sharedWith1' )
-> setSharedBy ( 'sharedBy1' )
2016-01-27 22:51:26 +03:00
-> setNode ( $path )
-> setTarget ( 'myTarget1' );
$share2 = $this -> manager -> newShare ();
$share2 -> setId ( 43 )
-> setProviderId ( 'prov' )
-> setShareType ( \OCP\Share :: SHARE_TYPE_GROUP )
2016-02-02 23:02:09 +03:00
-> setSharedWith ( 'sharedWith2' )
-> setSharedBy ( 'sharedBy2' )
2016-01-27 22:51:26 +03:00
-> setNode ( $path )
-> setTarget ( 'myTarget2' )
-> setParent ( 42 );
$share3 = $this -> manager -> newShare ();
$share3 -> setId ( 44 )
-> setProviderId ( 'prov' )
-> setShareType ( \OCP\Share :: SHARE_TYPE_LINK )
2016-02-02 23:02:09 +03:00
-> setSharedBy ( 'sharedBy3' )
2016-01-27 22:51:26 +03:00
-> setNode ( $path )
-> setTarget ( 'myTarget3' )
-> setParent ( 43 );
2015-11-10 16:14:49 +03:00
2016-01-13 16:21:55 +03:00
$this -> defaultProvider
2015-11-10 16:14:49 +03:00
-> method ( 'getChildren' )
2020-03-26 00:21:27 +03:00
-> willReturnMap ([
2015-11-10 16:14:49 +03:00
[ $share1 , [ $share2 ]],
[ $share2 , [ $share3 ]],
[ $share3 , []],
2020-03-26 00:21:27 +03:00
]);
2015-11-10 16:14:49 +03:00
$this -> defaultProvider
-> method ( 'delete' )
2019-11-22 15:23:56 +03:00
-> withConsecutive ([ $share3 ], [ $share2 ], [ $share1 ]);
2015-11-10 16:14:49 +03:00
2017-03-14 21:18:20 +03:00
$this -> eventDispatcher -> expects ( $this -> at ( 0 ))
-> method ( 'dispatch' )
-> with (
'OCP\Share::preUnshare' ,
2020-04-09 14:53:40 +03:00
$this -> callBack ( function ( GenericEvent $e ) use ( $share1 ) {
2017-03-14 21:18:20 +03:00
return $e -> getSubject () === $share1 ;
})
);
$this -> eventDispatcher -> expects ( $this -> at ( 1 ))
-> method ( 'dispatch' )
-> with (
'OCP\Share::postUnshare' ,
2020-04-09 14:53:40 +03:00
$this -> callBack ( function ( GenericEvent $e ) use ( $share1 , $share2 , $share3 ) {
2017-03-14 21:18:20 +03:00
return $e -> getSubject () === $share1 &&
$e -> getArgument ( 'deletedShares' ) === [ $share3 , $share2 , $share1 ];
})
);
2015-11-10 16:14:49 +03:00
$manager -> deleteShare ( $share1 );
}
2017-07-16 17:26:11 +03:00
public function testDeleteFromSelf () {
$manager = $this -> createManagerMock ()
-> setMethods ([ 'getShareById' ])
-> getMock ();
$recipientId = 'unshareFrom' ;
$share = $this -> manager -> newShare ();
$share -> setId ( 42 )
-> setProviderId ( 'prov' )
-> setShareType ( \OCP\Share :: SHARE_TYPE_USER )
-> setSharedWith ( 'sharedWith' )
-> setSharedBy ( 'sharedBy' )
-> setShareOwner ( 'shareOwner' )
-> setTarget ( 'myTarget' )
-> setNodeId ( 1 )
-> setNodeType ( 'file' );
$this -> defaultProvider
-> expects ( $this -> once ())
-> method ( 'deleteFromSelf' )
-> with ( $share , $recipientId );
$this -> eventDispatcher -> expects ( $this -> at ( 0 ))
-> method ( 'dispatch' )
-> with (
'OCP\Share::postUnshareFromSelf' ,
2020-04-09 14:53:40 +03:00
$this -> callBack ( function ( GenericEvent $e ) use ( $share ) {
2017-07-16 17:26:11 +03:00
return $e -> getSubject () === $share ;
})
);
$manager -> deleteFromSelf ( $share , $recipientId );
}
2015-11-10 16:14:49 +03:00
public function testDeleteChildren () {
2016-01-11 12:30:03 +03:00
$manager = $this -> createManagerMock ()
2015-11-10 16:14:49 +03:00
-> setMethods ([ 'deleteShare' ])
-> getMock ();
2016-09-02 12:24:43 +03:00
$share = $this -> createMock ( IShare :: class );
2016-01-13 15:02:23 +03:00
$share -> method ( 'getShareType' ) -> willReturn ( \OCP\Share :: SHARE_TYPE_USER );
2015-11-10 16:14:49 +03:00
2016-09-02 12:24:43 +03:00
$child1 = $this -> createMock ( IShare :: class );
2016-01-13 15:02:23 +03:00
$child1 -> method ( 'getShareType' ) -> willReturn ( \OCP\Share :: SHARE_TYPE_USER );
2016-09-02 12:24:43 +03:00
$child2 = $this -> createMock ( IShare :: class );
2016-01-13 15:02:23 +03:00
$child2 -> method ( 'getShareType' ) -> willReturn ( \OCP\Share :: SHARE_TYPE_USER );
2016-09-02 12:24:43 +03:00
$child3 = $this -> createMock ( IShare :: class );
2016-01-13 15:02:23 +03:00
$child3 -> method ( 'getShareType' ) -> willReturn ( \OCP\Share :: SHARE_TYPE_USER );
2015-11-10 16:14:49 +03:00
$shares = [
$child1 ,
$child2 ,
$child3 ,
];
2016-01-13 16:21:55 +03:00
$this -> defaultProvider
2015-11-10 16:14:49 +03:00
-> expects ( $this -> exactly ( 4 ))
-> method ( 'getChildren' )
2020-04-09 14:53:40 +03:00
-> willReturnCallback ( function ( $_share ) use ( $share , $shares ) {
2015-11-10 16:14:49 +03:00
if ( $_share === $share ) {
return $shares ;
}
return [];
2020-03-26 00:21:27 +03:00
});
2015-11-10 16:14:49 +03:00
2016-01-13 16:21:55 +03:00
$this -> defaultProvider
2015-11-10 16:14:49 +03:00
-> expects ( $this -> exactly ( 3 ))
-> method ( 'delete' )
2019-11-22 15:23:56 +03:00
-> withConsecutive ([ $child1 ], [ $child2 ], [ $child3 ]);
2015-11-10 16:14:49 +03:00
2016-12-19 19:15:55 +03:00
$result = self :: invokePrivate ( $manager , 'deleteChildren' , [ $share ]);
2015-11-10 16:14:49 +03:00
$this -> assertSame ( $shares , $result );
2015-10-30 15:10:08 +03:00
}
2015-11-23 16:06:25 +03:00
public function testGetShareById () {
2016-09-02 12:24:43 +03:00
$share = $this -> createMock ( IShare :: class );
2015-10-30 15:10:08 +03:00
$this -> defaultProvider
-> expects ( $this -> once ())
-> method ( 'getShareById' )
-> with ( 42 )
-> willReturn ( $share );
2016-01-13 15:02:23 +03:00
$this -> assertEquals ( $share , $this -> manager -> getShareById ( 'default:42' ));
2015-10-30 15:10:08 +03:00
}
2015-12-15 11:54:12 +03:00
2019-12-12 23:38:52 +03:00
2016-02-05 17:34:30 +03:00
public function testGetExpiredShareById () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \OCP\Share\Exceptions\ShareNotFound :: class );
2016-02-05 17:34:30 +03:00
$manager = $this -> createManagerMock ()
-> setMethods ([ 'deleteShare' ])
-> getMock ();
$date = new \DateTime ();
$date -> setTime ( 0 , 0 , 0 );
$share = $this -> manager -> newShare ();
$share -> setExpirationDate ( $date )
-> setShareType ( \OCP\Share :: SHARE_TYPE_LINK );
$this -> defaultProvider -> expects ( $this -> once ())
-> method ( 'getShareById' )
-> with ( '42' )
-> willReturn ( $share );
$manager -> expects ( $this -> once ())
-> method ( 'deleteShare' )
-> with ( $share );
$manager -> getShareById ( 'default:42' );
}
2019-12-12 23:38:52 +03:00
2015-12-15 11:54:12 +03:00
public function testVerifyPasswordNullButEnforced () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \InvalidArgumentException :: class );
$this -> expectExceptionMessage ( 'Passwords are enforced for link shares' );
2020-03-26 00:21:27 +03:00
$this -> config -> method ( 'getAppValue' ) -> willReturnMap ([
2015-12-15 11:54:12 +03:00
[ 'core' , 'shareapi_enforce_links_password' , 'no' , 'yes' ],
2020-03-26 00:21:27 +03:00
]);
2015-12-15 11:54:12 +03:00
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'verifyPassword' , [ null ]);
2015-12-15 11:54:12 +03:00
}
public function testVerifyPasswordNull () {
2020-03-26 00:21:27 +03:00
$this -> config -> method ( 'getAppValue' ) -> willReturnMap ([
2020-04-09 10:22:29 +03:00
[ 'core' , 'shareapi_enforce_links_password' , 'no' , 'no' ],
2020-03-26 00:21:27 +03:00
]);
2015-12-15 11:54:12 +03:00
2016-12-19 19:15:55 +03:00
$result = self :: invokePrivate ( $this -> manager , 'verifyPassword' , [ null ]);
2015-12-15 11:54:12 +03:00
$this -> assertNull ( $result );
}
public function testVerifyPasswordHook () {
2020-03-26 00:21:27 +03:00
$this -> config -> method ( 'getAppValue' ) -> willReturnMap ([
2020-04-09 10:22:29 +03:00
[ 'core' , 'shareapi_enforce_links_password' , 'no' , 'no' ],
2020-03-26 00:21:27 +03:00
]);
2015-12-15 11:54:12 +03:00
2016-06-27 11:46:39 +03:00
$this -> eventDispatcher -> expects ( $this -> once ()) -> method ( 'dispatch' )
2020-04-09 14:53:40 +03:00
-> willReturnCallback ( function ( Event $event ) {
2019-11-19 21:18:00 +03:00
$this -> assertInstanceOf ( ValidatePasswordPolicyEvent :: class , $event );
/** @var ValidatePasswordPolicyEvent $event */
$this -> assertSame ( 'password' , $event -> getPassword ());
2016-06-27 11:46:39 +03:00
}
2019-11-19 21:18:00 +03:00
);
2015-12-15 11:54:12 +03:00
2016-12-19 19:15:55 +03:00
$result = self :: invokePrivate ( $this -> manager , 'verifyPassword' , [ 'password' ]);
2015-12-15 11:54:12 +03:00
$this -> assertNull ( $result );
}
2019-12-12 23:38:52 +03:00
2015-12-15 11:54:12 +03:00
public function testVerifyPasswordHookFails () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \Exception :: class );
$this -> expectExceptionMessage ( 'password not accepted' );
2020-03-26 00:21:27 +03:00
$this -> config -> method ( 'getAppValue' ) -> willReturnMap ([
2020-04-09 10:22:29 +03:00
[ 'core' , 'shareapi_enforce_links_password' , 'no' , 'no' ],
2020-03-26 00:21:27 +03:00
]);
2015-12-15 11:54:12 +03:00
2016-06-27 11:46:39 +03:00
$this -> eventDispatcher -> expects ( $this -> once ()) -> method ( 'dispatch' )
2020-04-09 14:53:40 +03:00
-> willReturnCallback ( function ( Event $event ) {
2019-11-19 21:18:00 +03:00
$this -> assertInstanceOf ( ValidatePasswordPolicyEvent :: class , $event );
/** @var ValidatePasswordPolicyEvent $event */
$this -> assertSame ( 'password' , $event -> getPassword ());
2016-06-27 11:46:39 +03:00
throw new HintException ( 'message' , 'password not accepted' );
}
2019-11-19 21:18:00 +03:00
);
2016-06-27 11:46:39 +03:00
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'verifyPassword' , [ 'password' ]);
2015-12-15 11:54:12 +03:00
}
public function createShare ( $id , $type , $path , $sharedWith , $sharedBy , $shareOwner ,
$permissions , $expireDate = null , $password = null ) {
2016-09-02 12:24:43 +03:00
$share = $this -> createMock ( IShare :: class );
2015-12-15 11:54:12 +03:00
$share -> method ( 'getShareType' ) -> willReturn ( $type );
$share -> method ( 'getSharedWith' ) -> willReturn ( $sharedWith );
$share -> method ( 'getSharedBy' ) -> willReturn ( $sharedBy );
2016-04-08 15:31:06 +03:00
$share -> method ( 'getShareOwner' ) -> willReturn ( $shareOwner );
2016-01-27 22:51:26 +03:00
$share -> method ( 'getNode' ) -> willReturn ( $path );
2015-12-15 11:54:12 +03:00
$share -> method ( 'getPermissions' ) -> willReturn ( $permissions );
$share -> method ( 'getExpirationDate' ) -> willReturn ( $expireDate );
$share -> method ( 'getPassword' ) -> willReturn ( $password );
return $share ;
}
public function dataGeneralChecks () {
2016-02-02 23:02:09 +03:00
$user0 = 'user0' ;
$user2 = 'user1' ;
$group0 = 'group0' ;
2019-07-03 17:32:45 +03:00
$owner = $this -> createMock ( IUser :: class );
$owner -> method ( 'getUID' )
-> willReturn ( $user0 );
2015-12-15 11:54:12 +03:00
2016-09-02 12:24:43 +03:00
$file = $this -> createMock ( File :: class );
$node = $this -> createMock ( Node :: class );
2019-07-29 16:00:07 +03:00
$storage = $this -> createMock ( Storage\IStorage :: class );
$storage -> method ( 'instanceOfStorage' )
-> with ( '\OCA\Files_Sharing\External\Storage' )
-> willReturn ( false );
$file -> method ( 'getStorage' )
-> willReturn ( $storage );
$node -> method ( 'getStorage' )
-> willReturn ( $storage );
2015-12-15 11:54:12 +03:00
$data = [
2016-02-02 23:02:09 +03:00
[ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_USER , $file , null , $user0 , $user0 , 31 , null , null ), 'SharedWith is not a valid user' , true ],
[ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_USER , $file , $group0 , $user0 , $user0 , 31 , null , null ), 'SharedWith is not a valid user' , true ],
[ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_USER , $file , 'foo@bar.com' , $user0 , $user0 , 31 , null , null ), 'SharedWith is not a valid user' , true ],
[ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_GROUP , $file , null , $user0 , $user0 , 31 , null , null ), 'SharedWith is not a valid group' , true ],
[ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_GROUP , $file , $user2 , $user0 , $user0 , 31 , null , null ), 'SharedWith is not a valid group' , true ],
[ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_GROUP , $file , 'foo@bar.com' , $user0 , $user0 , 31 , null , null ), 'SharedWith is not a valid group' , true ],
[ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_LINK , $file , $user2 , $user0 , $user0 , 31 , null , null ), 'SharedWith should be empty' , true ],
[ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_LINK , $file , $group0 , $user0 , $user0 , 31 , null , null ), 'SharedWith should be empty' , true ],
[ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_LINK , $file , 'foo@bar.com' , $user0 , $user0 , 31 , null , null ), 'SharedWith should be empty' , true ],
2017-03-17 22:48:33 +03:00
[ $this -> createShare ( null , - 1 , $file , null , $user0 , $user0 , 31 , null , null ), 'unknown share type' , true ],
2016-02-02 23:02:09 +03:00
[ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_USER , $file , $user2 , null , $user0 , 31 , null , null ), 'SharedBy should be set' , true ],
[ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_GROUP , $file , $group0 , null , $user0 , 31 , null , null ), 'SharedBy should be set' , true ],
[ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_LINK , $file , null , null , $user0 , 31 , null , null ), 'SharedBy should be set' , true ],
2017-05-17 16:35:10 +03:00
[ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_USER , $file , $user0 , $user0 , $user0 , 31 , null , null ), 'Can’ t share with yourself' , true ],
2016-02-02 23:02:09 +03:00
[ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_USER , null , $user2 , $user0 , $user0 , 31 , null , null ), 'Path should be set' , true ],
[ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_GROUP , null , $group0 , $user0 , $user0 , 31 , null , null ), 'Path should be set' , true ],
[ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_LINK , null , null , $user0 , $user0 , 31 , null , null ), 'Path should be set' , true ],
[ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_USER , $node , $user2 , $user0 , $user0 , 31 , null , null ), 'Path should be either a file or a folder' , true ],
[ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_GROUP , $node , $group0 , $user0 , $user0 , 31 , null , null ), 'Path should be either a file or a folder' , true ],
[ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_LINK , $node , null , $user0 , $user0 , 31 , null , null ), 'Path should be either a file or a folder' , true ],
2015-12-15 11:54:12 +03:00
];
2016-09-02 12:24:43 +03:00
$nonShareAble = $this -> createMock ( Folder :: class );
2015-12-15 11:54:12 +03:00
$nonShareAble -> method ( 'isShareable' ) -> willReturn ( false );
2016-01-06 13:34:12 +03:00
$nonShareAble -> method ( 'getPath' ) -> willReturn ( 'path' );
2019-07-03 17:32:45 +03:00
$nonShareAble -> method ( 'getOwner' )
-> willReturn ( $owner );
2019-07-29 16:00:07 +03:00
$nonShareAble -> method ( 'getStorage' )
-> willReturn ( $storage );
2015-12-15 11:54:12 +03:00
2016-02-02 23:02:09 +03:00
$data [] = [ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_USER , $nonShareAble , $user2 , $user0 , $user0 , 31 , null , null ), 'You are not allowed to share path' , true ];
$data [] = [ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_GROUP , $nonShareAble , $group0 , $user0 , $user0 , 31 , null , null ), 'You are not allowed to share path' , true ];
$data [] = [ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_LINK , $nonShareAble , null , $user0 , $user0 , 31 , null , null ), 'You are not allowed to share path' , true ];
2015-12-15 11:54:12 +03:00
2016-09-02 12:24:43 +03:00
$limitedPermssions = $this -> createMock ( File :: class );
2015-12-15 11:54:12 +03:00
$limitedPermssions -> method ( 'isShareable' ) -> willReturn ( true );
$limitedPermssions -> method ( 'getPermissions' ) -> willReturn ( \OCP\Constants :: PERMISSION_READ );
2016-01-06 13:34:12 +03:00
$limitedPermssions -> method ( 'getPath' ) -> willReturn ( 'path' );
2019-07-02 11:22:30 +03:00
$limitedPermssions -> method ( 'getOwner' )
-> willReturn ( $owner );
2019-07-29 16:00:07 +03:00
$limitedPermssions -> method ( 'getStorage' )
-> willReturn ( $storage );
2019-07-02 11:22:30 +03:00
2016-02-02 23:02:09 +03:00
$data [] = [ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_USER , $limitedPermssions , $user2 , $user0 , $user0 , null , null , null ), 'A share requires permissions' , true ];
$data [] = [ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_GROUP , $limitedPermssions , $group0 , $user0 , $user0 , null , null , null ), 'A share requires permissions' , true ];
$data [] = [ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_LINK , $limitedPermssions , null , $user0 , $user0 , null , null , null ), 'A share requires permissions' , true ];
2015-12-15 11:54:12 +03:00
2016-09-02 12:24:43 +03:00
$mount = $this -> createMock ( MoveableMount :: class );
2016-03-30 14:33:16 +03:00
$limitedPermssions -> method ( 'getMountPoint' ) -> willReturn ( $mount );
2019-07-29 16:00:07 +03:00
2017-05-17 16:35:10 +03:00
$data [] = [ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_USER , $limitedPermssions , $user2 , $user0 , $user0 , 31 , null , null ), 'Can’ t increase permissions of path' , true ];
$data [] = [ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_GROUP , $limitedPermssions , $group0 , $user0 , $user0 , 17 , null , null ), 'Can’ t increase permissions of path' , true ];
$data [] = [ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_LINK , $limitedPermssions , null , $user0 , $user0 , 3 , null , null ), 'Can’ t increase permissions of path' , true ];
2015-12-15 11:54:12 +03:00
2016-09-02 12:24:43 +03:00
$nonMoveableMountPermssions = $this -> createMock ( Folder :: class );
2016-03-30 14:33:16 +03:00
$nonMoveableMountPermssions -> method ( 'isShareable' ) -> willReturn ( true );
$nonMoveableMountPermssions -> method ( 'getPermissions' ) -> willReturn ( \OCP\Constants :: PERMISSION_READ );
$nonMoveableMountPermssions -> method ( 'getPath' ) -> willReturn ( 'path' );
2019-07-03 17:32:45 +03:00
$nonMoveableMountPermssions -> method ( 'getOwner' )
-> willReturn ( $owner );
2019-07-29 16:00:07 +03:00
$nonMoveableMountPermssions -> method ( 'getStorage' )
-> willReturn ( $storage );
2016-03-30 14:33:16 +03:00
2017-05-17 16:35:10 +03:00
$data [] = [ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_USER , $nonMoveableMountPermssions , $user2 , $user0 , $user0 , 11 , null , null ), 'Can’ t increase permissions of path' , false ];
$data [] = [ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_GROUP , $nonMoveableMountPermssions , $group0 , $user0 , $user0 , 11 , null , null ), 'Can’ t increase permissions of path' , false ];
2016-03-30 14:33:16 +03:00
2016-09-02 12:24:43 +03:00
$rootFolder = $this -> createMock ( Folder :: class );
2016-02-26 18:05:32 +03:00
$rootFolder -> method ( 'isShareable' ) -> willReturn ( true );
$rootFolder -> method ( 'getPermissions' ) -> willReturn ( \OCP\Constants :: PERMISSION_ALL );
$rootFolder -> method ( 'getPath' ) -> willReturn ( 'myrootfolder' );
2017-05-17 16:35:10 +03:00
$data [] = [ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_USER , $rootFolder , $user2 , $user0 , $user0 , 30 , null , null ), 'You can’ t share your root folder' , true ];
$data [] = [ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_GROUP , $rootFolder , $group0 , $user0 , $user0 , 2 , null , null ), 'You can’ t share your root folder' , true ];
$data [] = [ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_LINK , $rootFolder , null , $user0 , $user0 , 16 , null , null ), 'You can’ t share your root folder' , true ];
2016-02-26 18:05:32 +03:00
2016-09-02 12:24:43 +03:00
$allPermssions = $this -> createMock ( Folder :: class );
2015-12-15 11:54:12 +03:00
$allPermssions -> method ( 'isShareable' ) -> willReturn ( true );
$allPermssions -> method ( 'getPermissions' ) -> willReturn ( \OCP\Constants :: PERMISSION_ALL );
2019-07-03 17:32:45 +03:00
$allPermssions -> method ( 'getOwner' )
-> willReturn ( $owner );
2019-07-29 16:00:07 +03:00
$allPermssions -> method ( 'getStorage' )
-> willReturn ( $storage );
2015-12-15 11:54:12 +03:00
2016-02-02 23:02:09 +03:00
$data [] = [ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_USER , $allPermssions , $user2 , $user0 , $user0 , 30 , null , null ), 'Shares need at least read permissions' , true ];
$data [] = [ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_GROUP , $allPermssions , $group0 , $user0 , $user0 , 2 , null , null ), 'Shares need at least read permissions' , true ];
2015-12-15 11:54:12 +03:00
2016-02-02 23:02:09 +03:00
$data [] = [ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_USER , $allPermssions , $user2 , $user0 , $user0 , 31 , null , null ), null , false ];
$data [] = [ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_GROUP , $allPermssions , $group0 , $user0 , $user0 , 3 , null , null ), null , false ];
$data [] = [ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_LINK , $allPermssions , null , $user0 , $user0 , 17 , null , null ), null , false ];
2015-12-15 11:54:12 +03:00
2019-07-29 16:00:07 +03:00
$remoteStorage = $this -> createMock ( Storage\IStorage :: class );
$remoteStorage -> method ( 'instanceOfStorage' )
-> with ( '\OCA\Files_Sharing\External\Storage' )
-> willReturn ( true );
$remoteFile = $this -> createMock ( Folder :: class );
$remoteFile -> method ( 'isShareable' ) -> willReturn ( true );
$remoteFile -> method ( 'getPermissions' ) -> willReturn ( \OCP\Constants :: PERMISSION_READ ^ \OCP\Constants :: PERMISSION_UPDATE );
$remoteFile -> method ( 'getOwner' )
-> willReturn ( $owner );
$remoteFile -> method ( 'getStorage' )
-> willReturn ( $storage );
$data [] = [ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_REMOTE , $remoteFile , $user2 , $user0 , $user0 , 1 , null , null ), null , false ];
$data [] = [ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_REMOTE , $remoteFile , $user2 , $user0 , $user0 , 3 , null , null ), null , false ];
$data [] = [ $this -> createShare ( null , \OCP\Share :: SHARE_TYPE_REMOTE , $remoteFile , $user2 , $user0 , $user0 , 31 , null , null ), 'Can’ t increase permissions of ' , true ];
2015-12-15 11:54:12 +03:00
return $data ;
}
/**
* @ dataProvider dataGeneralChecks
*
* @ param $share
* @ param $exceptionMessage
2016-12-19 19:15:55 +03:00
* @ param $exception
2015-12-15 11:54:12 +03:00
*/
public function testGeneralChecks ( $share , $exceptionMessage , $exception ) {
$thrown = null ;
2020-03-26 00:21:27 +03:00
$this -> userManager -> method ( 'userExists' ) -> willReturnMap ([
2016-02-02 23:02:09 +03:00
[ 'user0' , true ],
[ 'user1' , true ],
2020-03-26 00:21:27 +03:00
]);
2016-02-02 23:02:09 +03:00
2020-03-26 00:21:27 +03:00
$this -> groupManager -> method ( 'groupExists' ) -> willReturnMap ([
2016-02-02 23:02:09 +03:00
[ 'group0' , true ],
2020-03-26 00:21:27 +03:00
]);
2016-02-02 23:02:09 +03:00
2016-09-02 12:24:43 +03:00
$userFolder = $this -> createMock ( Folder :: class );
2016-02-26 18:05:32 +03:00
$userFolder -> method ( 'getPath' ) -> willReturn ( 'myrootfolder' );
2020-02-18 13:02:11 +03:00
$userFolder -> expects ( $this -> any ())
-> method ( 'getRelativePath' )
-> willReturnArgument ( 0 );
2016-02-25 22:22:35 +03:00
$this -> rootFolder -> method ( 'getUserFolder' ) -> willReturn ( $userFolder );
2016-02-26 18:05:32 +03:00
2015-12-15 11:54:12 +03:00
try {
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'generalCreateChecks' , [ $share ]);
2015-12-15 11:54:12 +03:00
$thrown = false ;
2016-02-02 16:18:59 +03:00
} catch ( \OCP\Share\Exceptions\GenericShareException $e ) {
2016-01-06 13:34:12 +03:00
$this -> assertEquals ( $exceptionMessage , $e -> getHint ());
$thrown = true ;
2020-04-10 15:19:56 +03:00
} catch ( \InvalidArgumentException $e ) {
2015-12-15 11:54:12 +03:00
$this -> assertEquals ( $exceptionMessage , $e -> getMessage ());
$thrown = true ;
}
$this -> assertSame ( $exception , $thrown );
}
2019-12-12 23:38:52 +03:00
2016-02-25 22:22:35 +03:00
public function testGeneralCheckShareRoot () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \InvalidArgumentException :: class );
$this -> expectExceptionMessage ( 'You can’ t share your root folder' );
2016-02-25 22:22:35 +03:00
$thrown = null ;
2020-03-26 00:21:27 +03:00
$this -> userManager -> method ( 'userExists' ) -> willReturnMap ([
2016-02-25 22:22:35 +03:00
[ 'user0' , true ],
[ 'user1' , true ],
2020-03-26 00:21:27 +03:00
]);
2016-02-25 22:22:35 +03:00
2016-09-02 12:24:43 +03:00
$userFolder = $this -> createMock ( Folder :: class );
2016-02-25 22:22:35 +03:00
$userFolder -> method ( 'isSubNode' ) -> with ( $userFolder ) -> willReturn ( false );
$this -> rootFolder -> method ( 'getUserFolder' ) -> willReturn ( $userFolder );
$share = $this -> manager -> newShare ();
$share -> setShareType ( \OCP\Share :: SHARE_TYPE_USER )
-> setSharedWith ( 'user0' )
-> setSharedBy ( 'user1' )
-> setNode ( $userFolder );
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'generalCreateChecks' , [ $share ]);
2016-02-25 22:22:35 +03:00
}
2019-12-12 23:38:52 +03:00
2016-01-26 16:29:30 +03:00
public function testvalidateExpirationDateInPast () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \OCP\Share\Exceptions\GenericShareException :: class );
$this -> expectExceptionMessage ( 'Expiration date is in the past' );
2015-12-15 11:54:12 +03:00
// Expire date in the past
$past = new \DateTime ();
$past -> sub ( new \DateInterval ( 'P1D' ));
2016-01-30 01:04:42 +03:00
$share = $this -> manager -> newShare ();
$share -> setExpirationDate ( $past );
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'validateExpirationDate' , [ $share ]);
2015-12-15 11:54:12 +03:00
}
2019-12-12 23:38:52 +03:00
2016-01-26 16:29:30 +03:00
public function testvalidateExpirationDateEnforceButNotSet () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \InvalidArgumentException :: class );
$this -> expectExceptionMessage ( 'Expiration date is enforced' );
2016-01-30 01:04:42 +03:00
$share = $this -> manager -> newShare ();
2016-02-25 16:21:46 +03:00
$share -> setProviderId ( 'foo' ) -> setId ( 'bar' );
2016-01-30 01:04:42 +03:00
2015-12-15 11:54:12 +03:00
$this -> config -> method ( 'getAppValue' )
2020-03-26 00:21:27 +03:00
-> willReturnMap ([
2016-02-26 13:38:06 +03:00
[ 'core' , 'shareapi_default_expire_date' , 'no' , 'yes' ],
2015-12-15 11:54:12 +03:00
[ 'core' , 'shareapi_enforce_expire_date' , 'no' , 'yes' ],
2020-03-26 00:21:27 +03:00
]);
2015-12-15 11:54:12 +03:00
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'validateExpirationDate' , [ $share ]);
2015-12-15 11:54:12 +03:00
}
2016-02-26 13:38:06 +03:00
public function testvalidateExpirationDateEnforceButNotEnabledAndNotSet () {
$share = $this -> manager -> newShare ();
$share -> setProviderId ( 'foo' ) -> setId ( 'bar' );
$this -> config -> method ( 'getAppValue' )
2020-03-26 00:21:27 +03:00
-> willReturnMap ([
2016-02-26 13:38:06 +03:00
[ 'core' , 'shareapi_enforce_expire_date' , 'no' , 'yes' ],
2020-03-26 00:21:27 +03:00
]);
2016-02-26 13:38:06 +03:00
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'validateExpirationDate' , [ $share ]);
2016-02-26 13:38:06 +03:00
$this -> assertNull ( $share -> getExpirationDate ());
}
2016-02-25 16:21:46 +03:00
public function testvalidateExpirationDateEnforceButNotSetNewShare () {
$share = $this -> manager -> newShare ();
$this -> config -> method ( 'getAppValue' )
2020-03-26 00:21:27 +03:00
-> willReturnMap ([
2016-02-25 16:21:46 +03:00
[ 'core' , 'shareapi_enforce_expire_date' , 'no' , 'yes' ],
[ 'core' , 'shareapi_expire_after_n_days' , '7' , '3' ],
[ 'core' , 'shareapi_default_expire_date' , 'no' , 'yes' ],
2020-04-21 15:10:33 +03:00
[ 'core' , 'link_defaultExpDays' , 3 , '3' ],
2020-03-26 00:21:27 +03:00
]);
2016-02-25 16:21:46 +03:00
$expected = new \DateTime ();
$expected -> setTime ( 0 , 0 , 0 );
$expected -> add ( new \DateInterval ( 'P3D' ));
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'validateExpirationDate' , [ $share ]);
2016-02-25 16:21:46 +03:00
$this -> assertNotNull ( $share -> getExpirationDate ());
$this -> assertEquals ( $expected , $share -> getExpirationDate ());
}
2016-01-26 16:29:30 +03:00
public function testvalidateExpirationDateEnforceToFarIntoFuture () {
2015-12-15 11:54:12 +03:00
// Expire date in the past
$future = new \DateTime ();
$future -> add ( new \DateInterval ( 'P7D' ));
2016-01-30 01:04:42 +03:00
$share = $this -> manager -> newShare ();
$share -> setExpirationDate ( $future );
2015-12-15 11:54:12 +03:00
$this -> config -> method ( 'getAppValue' )
2020-03-26 00:21:27 +03:00
-> willReturnMap ([
2015-12-15 11:54:12 +03:00
[ 'core' , 'shareapi_enforce_expire_date' , 'no' , 'yes' ],
[ 'core' , 'shareapi_expire_after_n_days' , '7' , '3' ],
2020-03-26 00:21:27 +03:00
]);
2015-12-15 11:54:12 +03:00
2016-01-05 14:50:00 +03:00
try {
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'validateExpirationDate' , [ $share ]);
2018-01-25 13:23:12 +03:00
$this -> addToAssertionCount ( 1 );
2016-02-02 16:18:59 +03:00
} catch ( \OCP\Share\Exceptions\GenericShareException $e ) {
2016-01-05 14:50:00 +03:00
$this -> assertEquals ( 'Cannot set expiration date more than 3 days in the future' , $e -> getMessage ());
$this -> assertEquals ( 'Cannot set expiration date more than 3 days in the future' , $e -> getHint ());
$this -> assertEquals ( 404 , $e -> getCode ());
}
2015-12-15 11:54:12 +03:00
}
2016-01-26 16:29:30 +03:00
public function testvalidateExpirationDateEnforceValid () {
2015-12-15 11:54:12 +03:00
// Expire date in the past
$future = new \DateTime ();
$future -> add ( new \DateInterval ( 'P2D' ));
$future -> setTime ( 0 , 0 , 0 );
2016-01-30 01:04:42 +03:00
$expected = clone $future ;
2015-12-15 11:54:12 +03:00
$future -> setTime ( 1 , 2 , 3 );
2016-01-30 01:04:42 +03:00
$share = $this -> manager -> newShare ();
$share -> setExpirationDate ( $future );
2015-12-15 11:54:12 +03:00
$this -> config -> method ( 'getAppValue' )
2020-03-26 00:21:27 +03:00
-> willReturnMap ([
2015-12-15 11:54:12 +03:00
[ 'core' , 'shareapi_enforce_expire_date' , 'no' , 'yes' ],
[ 'core' , 'shareapi_expire_after_n_days' , '7' , '3' ],
2020-03-26 00:21:27 +03:00
]);
2015-12-15 11:54:12 +03:00
2016-01-30 01:04:42 +03:00
$hookListner = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'listener' ]) -> getMock ();
\OCP\Util :: connectHook ( '\OC\Share' , 'verifyExpirationDate' , $hookListner , 'listener' );
$hookListner -> expects ( $this -> once ()) -> method ( 'listener' ) -> with ( $this -> callback ( function ( $data ) use ( $future ) {
return $data [ 'expirationDate' ] == $future ;
}));
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'validateExpirationDate' , [ $share ]);
2015-12-15 11:54:12 +03:00
2016-02-25 16:21:46 +03:00
$this -> assertEquals ( $expected , $share -> getExpirationDate ());
2015-12-15 11:54:12 +03:00
}
2016-01-26 16:29:30 +03:00
public function testvalidateExpirationDateNoDateNoDefaultNull () {
2015-12-15 11:54:12 +03:00
$date = new \DateTime ();
$date -> add ( new \DateInterval ( 'P5D' ));
2016-01-30 01:04:42 +03:00
$expected = clone $date ;
$expected -> setTime ( 0 , 0 , 0 );
$share = $this -> manager -> newShare ();
$share -> setExpirationDate ( $date );
$hookListner = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'listener' ]) -> getMock ();
\OCP\Util :: connectHook ( '\OC\Share' , 'verifyExpirationDate' , $hookListner , 'listener' );
$hookListner -> expects ( $this -> once ()) -> method ( 'listener' ) -> with ( $this -> callback ( function ( $data ) use ( $expected ) {
2016-02-25 17:39:02 +03:00
return $data [ 'expirationDate' ] == $expected && $data [ 'passwordSet' ] === false ;
2016-01-30 01:04:42 +03:00
}));
2015-12-15 11:54:12 +03:00
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'validateExpirationDate' , [ $share ]);
2016-01-30 01:04:42 +03:00
2016-02-25 16:21:46 +03:00
$this -> assertEquals ( $expected , $share -> getExpirationDate ());
2015-12-15 11:54:12 +03:00
}
2016-01-26 16:29:30 +03:00
public function testvalidateExpirationDateNoDateNoDefault () {
2016-01-30 01:04:42 +03:00
$hookListner = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'listener' ]) -> getMock ();
\OCP\Util :: connectHook ( '\OC\Share' , 'verifyExpirationDate' , $hookListner , 'listener' );
$hookListner -> expects ( $this -> once ()) -> method ( 'listener' ) -> with ( $this -> callback ( function ( $data ) {
2016-02-25 17:39:02 +03:00
return $data [ 'expirationDate' ] === null && $data [ 'passwordSet' ] === true ;
2016-01-30 01:04:42 +03:00
}));
$share = $this -> manager -> newShare ();
2016-02-25 17:39:02 +03:00
$share -> setPassword ( 'password' );
2016-01-30 01:04:42 +03:00
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'validateExpirationDate' , [ $share ]);
2015-12-15 11:54:12 +03:00
2016-02-25 16:21:46 +03:00
$this -> assertNull ( $share -> getExpirationDate ());
2015-12-15 11:54:12 +03:00
}
2016-01-26 16:29:30 +03:00
public function testvalidateExpirationDateNoDateDefault () {
2015-12-15 11:54:12 +03:00
$future = new \DateTime ();
$future -> add ( new \DateInterval ( 'P3D' ));
$future -> setTime ( 0 , 0 , 0 );
2016-01-30 01:04:42 +03:00
$expected = clone $future ;
$share = $this -> manager -> newShare ();
$share -> setExpirationDate ( $future );
2015-12-15 11:54:12 +03:00
$this -> config -> method ( 'getAppValue' )
2020-03-26 00:21:27 +03:00
-> willReturnMap ([
2015-12-15 11:54:12 +03:00
[ 'core' , 'shareapi_default_expire_date' , 'no' , 'yes' ],
[ 'core' , 'shareapi_expire_after_n_days' , '7' , '3' ],
2020-03-26 00:21:27 +03:00
]);
2015-12-15 11:54:12 +03:00
2016-01-30 01:04:42 +03:00
$hookListner = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'listener' ]) -> getMock ();
\OCP\Util :: connectHook ( '\OC\Share' , 'verifyExpirationDate' , $hookListner , 'listener' );
$hookListner -> expects ( $this -> once ()) -> method ( 'listener' ) -> with ( $this -> callback ( function ( $data ) use ( $expected ) {
return $data [ 'expirationDate' ] == $expected ;
}));
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'validateExpirationDate' , [ $share ]);
2016-01-30 01:04:42 +03:00
$this -> assertEquals ( $expected , $share -> getExpirationDate ());
}
public function testValidateExpirationDateHookModification () {
$nextWeek = new \DateTime ();
$nextWeek -> add ( new \DateInterval ( 'P7D' ));
$nextWeek -> setTime ( 0 , 0 , 0 );
2015-12-15 11:54:12 +03:00
2016-01-30 01:04:42 +03:00
$save = clone $nextWeek ;
$hookListner = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'listener' ]) -> getMock ();
\OCP\Util :: connectHook ( '\OC\Share' , 'verifyExpirationDate' , $hookListner , 'listener' );
2020-03-26 00:21:27 +03:00
$hookListner -> expects ( $this -> once ()) -> method ( 'listener' ) -> willReturnCallback ( function ( $data ) {
2016-01-30 01:04:42 +03:00
$data [ 'expirationDate' ] -> sub ( new \DateInterval ( 'P2D' ));
2020-03-26 00:21:27 +03:00
});
2016-01-30 01:04:42 +03:00
$share = $this -> manager -> newShare ();
$share -> setExpirationDate ( $nextWeek );
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'validateExpirationDate' , [ $share ]);
2016-01-30 01:04:42 +03:00
$save -> sub ( new \DateInterval ( 'P2D' ));
$this -> assertEquals ( $save , $share -> getExpirationDate ());
}
2019-12-12 23:38:52 +03:00
2016-01-30 01:04:42 +03:00
public function testValidateExpirationDateHookException () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \Exception :: class );
$this -> expectExceptionMessage ( 'Invalid date!' );
2016-01-30 01:04:42 +03:00
$nextWeek = new \DateTime ();
$nextWeek -> add ( new \DateInterval ( 'P7D' ));
$nextWeek -> setTime ( 0 , 0 , 0 );
$share = $this -> manager -> newShare ();
$share -> setExpirationDate ( $nextWeek );
$hookListner = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'listener' ]) -> getMock ();
\OCP\Util :: connectHook ( '\OC\Share' , 'verifyExpirationDate' , $hookListner , 'listener' );
2020-03-26 00:21:27 +03:00
$hookListner -> expects ( $this -> once ()) -> method ( 'listener' ) -> willReturnCallback ( function ( $data ) {
2016-01-30 01:04:42 +03:00
$data [ 'accepted' ] = false ;
$data [ 'message' ] = 'Invalid date!' ;
2020-03-26 00:21:27 +03:00
});
2016-01-30 01:04:42 +03:00
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'validateExpirationDate' , [ $share ]);
2015-12-15 11:54:12 +03:00
}
2016-02-08 12:42:15 +03:00
public function testValidateExpirationDateExistingShareNoDefault () {
$share = $this -> manager -> newShare ();
$share -> setId ( '42' ) -> setProviderId ( 'foo' );
$this -> config -> method ( 'getAppValue' )
2020-03-26 00:21:27 +03:00
-> willReturnMap ([
2016-02-08 12:42:15 +03:00
[ 'core' , 'shareapi_default_expire_date' , 'no' , 'yes' ],
[ 'core' , 'shareapi_expire_after_n_days' , '7' , '6' ],
2020-03-26 00:21:27 +03:00
]);
2016-02-08 12:42:15 +03:00
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'validateExpirationDate' , [ $share ]);
2016-02-08 12:42:15 +03:00
$this -> assertEquals ( null , $share -> getExpirationDate ());
}
2019-12-12 23:38:52 +03:00
2015-12-15 11:54:12 +03:00
public function testUserCreateChecksShareWithGroupMembersOnlyDifferentGroups () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \Exception :: class );
$this -> expectExceptionMessage ( 'Sharing is only allowed with group members' );
2016-02-04 14:51:23 +03:00
$share = $this -> manager -> newShare ();
2015-12-15 11:54:12 +03:00
2016-09-02 12:24:43 +03:00
$sharedBy = $this -> createMock ( IUser :: class );
$sharedWith = $this -> createMock ( IUser :: class );
2016-02-02 23:02:09 +03:00
$share -> setSharedBy ( 'sharedBy' ) -> setSharedWith ( 'sharedWith' );
2015-12-15 11:54:12 +03:00
$this -> groupManager
-> method ( 'getUserGroupIds' )
2020-03-26 00:21:27 +03:00
-> willReturnMap (
[
2015-12-15 11:54:12 +03:00
[ $sharedBy , [ 'group1' ]],
[ $sharedWith , [ 'group2' ]],
2020-03-26 00:21:27 +03:00
]
2015-12-15 11:54:12 +03:00
);
2020-03-26 00:21:27 +03:00
$this -> userManager -> method ( 'get' ) -> willReturnMap ([
2016-02-02 23:02:09 +03:00
[ 'sharedBy' , $sharedBy ],
[ 'sharedWith' , $sharedWith ],
2020-03-26 00:21:27 +03:00
]);
2016-02-02 23:02:09 +03:00
2015-12-15 11:54:12 +03:00
$this -> config
-> method ( 'getAppValue' )
2020-03-26 00:21:27 +03:00
-> willReturnMap ([
2015-12-15 11:54:12 +03:00
[ 'core' , 'shareapi_only_share_with_group_members' , 'no' , 'yes' ],
2020-03-26 00:21:27 +03:00
]);
2015-12-15 11:54:12 +03:00
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'userCreateChecks' , [ $share ]);
2015-12-15 11:54:12 +03:00
}
public function testUserCreateChecksShareWithGroupMembersOnlySharedGroup () {
2016-02-04 14:51:23 +03:00
$share = $this -> manager -> newShare ();
2015-12-15 11:54:12 +03:00
2016-09-02 12:24:43 +03:00
$sharedBy = $this -> createMock ( IUser :: class );
$sharedWith = $this -> createMock ( IUser :: class );
2016-02-02 23:02:09 +03:00
$share -> setSharedBy ( 'sharedBy' ) -> setSharedWith ( 'sharedWith' );
2015-12-15 11:54:12 +03:00
2016-09-02 12:24:43 +03:00
$path = $this -> createMock ( Node :: class );
2016-01-27 22:51:26 +03:00
$share -> setNode ( $path );
2015-12-15 11:54:12 +03:00
$this -> groupManager
-> method ( 'getUserGroupIds' )
2020-03-26 00:21:27 +03:00
-> willReturnMap (
[
2015-12-15 11:54:12 +03:00
[ $sharedBy , [ 'group1' , 'group3' ]],
[ $sharedWith , [ 'group2' , 'group3' ]],
2020-03-26 00:21:27 +03:00
]
2015-12-15 11:54:12 +03:00
);
2020-03-26 00:21:27 +03:00
$this -> userManager -> method ( 'get' ) -> willReturnMap ([
2016-02-02 23:02:09 +03:00
[ 'sharedBy' , $sharedBy ],
[ 'sharedWith' , $sharedWith ],
2020-03-26 00:21:27 +03:00
]);
2016-02-02 23:02:09 +03:00
2015-12-15 11:54:12 +03:00
$this -> config
-> method ( 'getAppValue' )
2020-03-26 00:21:27 +03:00
-> willReturnMap ([
2015-12-15 11:54:12 +03:00
[ 'core' , 'shareapi_only_share_with_group_members' , 'no' , 'yes' ],
2020-03-26 00:21:27 +03:00
]);
2015-12-15 11:54:12 +03:00
$this -> defaultProvider
-> method ( 'getSharesByPath' )
-> with ( $path )
-> willReturn ([]);
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'userCreateChecks' , [ $share ]);
2018-01-25 13:23:12 +03:00
$this -> addToAssertionCount ( 1 );
2015-12-15 11:54:12 +03:00
}
2019-12-12 23:38:52 +03:00
2015-12-15 11:54:12 +03:00
public function testUserCreateChecksIdenticalShareExists () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \Exception :: class );
$this -> expectExceptionMessage ( 'Path is already shared with this user' );
2016-01-27 22:51:26 +03:00
$share = $this -> manager -> newShare ();
$share2 = $this -> manager -> newShare ();
2015-12-15 11:54:12 +03:00
2016-09-02 12:24:43 +03:00
$sharedWith = $this -> createMock ( IUser :: class );
$path = $this -> createMock ( Node :: class );
2016-01-25 14:09:56 +03:00
2016-02-02 23:02:09 +03:00
$share -> setSharedWith ( 'sharedWith' ) -> setNode ( $path )
2016-01-25 14:09:56 +03:00
-> setProviderId ( 'foo' ) -> setId ( 'bar' );
2016-02-02 23:02:09 +03:00
$share2 -> setSharedWith ( 'sharedWith' ) -> setNode ( $path )
2016-01-25 14:09:56 +03:00
-> setProviderId ( 'foo' ) -> setId ( 'baz' );
2015-12-15 11:54:12 +03:00
$this -> defaultProvider
-> method ( 'getSharesByPath' )
-> with ( $path )
2016-01-25 14:09:56 +03:00
-> willReturn ([ $share2 ]);
2015-12-15 11:54:12 +03:00
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'userCreateChecks' , [ $share ]);
2015-12-15 11:54:12 +03:00
}
2019-12-12 23:38:52 +03:00
2020-04-09 10:22:29 +03:00
public function testUserCreateChecksIdenticalPathSharedViaGroup () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \Exception :: class );
$this -> expectExceptionMessage ( 'Path is already shared with this user' );
2016-01-27 22:51:26 +03:00
$share = $this -> manager -> newShare ();
2016-01-25 14:09:56 +03:00
2016-09-02 12:24:43 +03:00
$sharedWith = $this -> createMock ( IUser :: class );
2016-02-02 23:02:09 +03:00
$sharedWith -> method ( 'getUID' ) -> willReturn ( 'sharedWith' );
$this -> userManager -> method ( 'get' ) -> with ( 'sharedWith' ) -> willReturn ( $sharedWith );
2016-09-02 12:24:43 +03:00
$path = $this -> createMock ( Node :: class );
2016-01-25 14:09:56 +03:00
2016-02-02 23:02:09 +03:00
$share -> setSharedWith ( 'sharedWith' )
2016-01-27 22:51:26 +03:00
-> setNode ( $path )
2016-02-02 23:02:09 +03:00
-> setShareOwner ( 'shareOwner' )
2016-01-25 14:09:56 +03:00
-> setProviderId ( 'foo' )
-> setId ( 'bar' );
2015-12-15 11:54:12 +03:00
2016-02-04 14:51:23 +03:00
$share2 = $this -> manager -> newShare ();
2015-12-15 11:54:12 +03:00
$share2 -> setShareType ( \OCP\Share :: SHARE_TYPE_GROUP )
2016-02-02 23:02:09 +03:00
-> setShareOwner ( 'shareOwner2' )
2016-01-25 14:09:56 +03:00
-> setProviderId ( 'foo' )
2016-02-02 23:02:09 +03:00
-> setId ( 'baz' )
-> setSharedWith ( 'group' );
2015-12-15 11:54:12 +03:00
2016-09-02 12:24:43 +03:00
$group = $this -> createMock ( IGroup :: class );
2015-12-15 11:54:12 +03:00
$group -> method ( 'inGroup' )
-> with ( $sharedWith )
-> willReturn ( true );
2016-02-02 23:02:09 +03:00
$this -> groupManager -> method ( 'get' ) -> with ( 'group' ) -> willReturn ( $group );
2015-12-15 11:54:12 +03:00
$this -> defaultProvider
-> method ( 'getSharesByPath' )
-> with ( $path )
-> willReturn ([ $share2 ]);
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'userCreateChecks' , [ $share ]);
2015-12-15 11:54:12 +03:00
}
2020-04-09 10:22:29 +03:00
public function testUserCreateChecksIdenticalPathSharedViaDeletedGroup () {
2017-01-19 17:02:46 +03:00
$share = $this -> manager -> newShare ();
2017-04-10 17:53:58 +03:00
$sharedWith = $this -> createMock ( IUser :: class );
2017-01-19 17:02:46 +03:00
$sharedWith -> method ( 'getUID' ) -> willReturn ( 'sharedWith' );
$this -> userManager -> method ( 'get' ) -> with ( 'sharedWith' ) -> willReturn ( $sharedWith );
2017-04-10 17:53:58 +03:00
$path = $this -> createMock ( Node :: class );
2017-01-19 17:02:46 +03:00
$share -> setSharedWith ( 'sharedWith' )
-> setNode ( $path )
-> setShareOwner ( 'shareOwner' )
-> setProviderId ( 'foo' )
-> setId ( 'bar' );
$share2 = $this -> manager -> newShare ();
$share2 -> setShareType ( \OCP\Share :: SHARE_TYPE_GROUP )
-> setShareOwner ( 'shareOwner2' )
-> setProviderId ( 'foo' )
-> setId ( 'baz' )
-> setSharedWith ( 'group' );
$this -> groupManager -> method ( 'get' ) -> with ( 'group' ) -> willReturn ( null );
$this -> defaultProvider
-> method ( 'getSharesByPath' )
-> with ( $path )
-> willReturn ([ $share2 ]);
$this -> assertNull ( $this -> invokePrivate ( $this -> manager , 'userCreateChecks' , [ $share ]));
}
2016-01-25 14:09:56 +03:00
public function testUserCreateChecksIdenticalPathNotSharedWithUser () {
2016-02-04 14:51:23 +03:00
$share = $this -> manager -> newShare ();
2016-09-02 12:24:43 +03:00
$sharedWith = $this -> createMock ( IUser :: class );
$path = $this -> createMock ( Node :: class );
2016-02-02 23:02:09 +03:00
$share -> setSharedWith ( 'sharedWith' )
2016-01-27 22:51:26 +03:00
-> setNode ( $path )
2016-02-02 23:02:09 +03:00
-> setShareOwner ( 'shareOwner' )
2016-01-25 14:09:56 +03:00
-> setProviderId ( 'foo' )
-> setId ( 'bar' );
2015-12-15 11:54:12 +03:00
2016-02-02 23:02:09 +03:00
$this -> userManager -> method ( 'get' ) -> with ( 'sharedWith' ) -> willReturn ( $sharedWith );
2016-02-04 14:51:23 +03:00
$share2 = $this -> manager -> newShare ();
2015-12-15 11:54:12 +03:00
$share2 -> setShareType ( \OCP\Share :: SHARE_TYPE_GROUP )
2016-02-02 23:02:09 +03:00
-> setShareOwner ( 'shareOwner2' )
2016-01-25 14:09:56 +03:00
-> setProviderId ( 'foo' )
-> setId ( 'baz' );
2015-12-15 11:54:12 +03:00
2016-09-02 12:24:43 +03:00
$group = $this -> createMock ( IGroup :: class );
2015-12-15 11:54:12 +03:00
$group -> method ( 'inGroup' )
-> with ( $sharedWith )
-> willReturn ( false );
2016-02-02 23:02:09 +03:00
$this -> groupManager -> method ( 'get' ) -> with ( 'group' ) -> willReturn ( $group );
$share2 -> setSharedWith ( 'group' );
2015-12-15 11:54:12 +03:00
$this -> defaultProvider
-> method ( 'getSharesByPath' )
-> with ( $path )
-> willReturn ([ $share2 ]);
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'userCreateChecks' , [ $share ]);
2018-01-25 13:23:12 +03:00
$this -> addToAssertionCount ( 1 );
2015-12-15 11:54:12 +03:00
}
2019-12-12 23:38:52 +03:00
2016-03-18 18:36:27 +03:00
public function testGroupCreateChecksShareWithGroupMembersGroupSharingNotAllowed () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \Exception :: class );
$this -> expectExceptionMessage ( 'Group sharing is now allowed' );
2016-03-18 18:36:27 +03:00
$share = $this -> manager -> newShare ();
$this -> config
-> method ( 'getAppValue' )
2020-03-26 00:21:27 +03:00
-> willReturnMap ([
2016-03-18 18:36:27 +03:00
[ 'core' , 'shareapi_allow_group_sharing' , 'yes' , 'no' ],
2020-03-26 00:21:27 +03:00
]);
2016-03-18 18:36:27 +03:00
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'groupCreateChecks' , [ $share ]);
2016-03-18 18:36:27 +03:00
}
2019-12-12 23:38:52 +03:00
2015-12-15 11:54:12 +03:00
public function testGroupCreateChecksShareWithGroupMembersOnlyNotInGroup () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \Exception :: class );
$this -> expectExceptionMessage ( 'Sharing is only allowed within your own groups' );
2016-02-04 14:51:23 +03:00
$share = $this -> manager -> newShare ();
2015-12-15 11:54:12 +03:00
2016-09-02 12:24:43 +03:00
$user = $this -> createMock ( IUser :: class );
$group = $this -> createMock ( IGroup :: class );
2016-02-02 23:02:09 +03:00
$share -> setSharedBy ( 'user' ) -> setSharedWith ( 'group' );
2015-12-15 11:54:12 +03:00
2016-02-02 23:02:09 +03:00
$group -> method ( 'inGroup' ) -> with ( $user ) -> willReturn ( false );
$this -> groupManager -> method ( 'get' ) -> with ( 'group' ) -> willReturn ( $group );
$this -> userManager -> method ( 'get' ) -> with ( 'user' ) -> willReturn ( $user );
2015-12-15 11:54:12 +03:00
$this -> config
-> method ( 'getAppValue' )
2020-03-26 00:21:27 +03:00
-> willReturnMap ([
2015-12-15 11:54:12 +03:00
[ 'core' , 'shareapi_only_share_with_group_members' , 'no' , 'yes' ],
2016-03-18 18:36:27 +03:00
[ 'core' , 'shareapi_allow_group_sharing' , 'yes' , 'yes' ],
2020-03-26 00:21:27 +03:00
]);
2015-12-15 11:54:12 +03:00
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'groupCreateChecks' , [ $share ]);
2015-12-15 11:54:12 +03:00
}
2019-12-12 23:38:52 +03:00
2017-01-19 17:02:46 +03:00
public function testGroupCreateChecksShareWithGroupMembersOnlyNullGroup () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \Exception :: class );
$this -> expectExceptionMessage ( 'Sharing is only allowed within your own groups' );
2017-01-19 17:02:46 +03:00
$share = $this -> manager -> newShare ();
2017-04-10 17:53:58 +03:00
$user = $this -> createMock ( IUser :: class );
2017-01-19 17:02:46 +03:00
$share -> setSharedBy ( 'user' ) -> setSharedWith ( 'group' );
$this -> groupManager -> method ( 'get' ) -> with ( 'group' ) -> willReturn ( null );
$this -> userManager -> method ( 'get' ) -> with ( 'user' ) -> willReturn ( $user );
$this -> config
-> method ( 'getAppValue' )
2020-03-26 00:21:27 +03:00
-> willReturnMap ([
2017-01-19 17:02:46 +03:00
[ 'core' , 'shareapi_only_share_with_group_members' , 'no' , 'yes' ],
[ 'core' , 'shareapi_allow_group_sharing' , 'yes' , 'yes' ],
2020-03-26 00:21:27 +03:00
]);
2017-01-19 17:02:46 +03:00
$this -> assertNull ( $this -> invokePrivate ( $this -> manager , 'groupCreateChecks' , [ $share ]));
}
2015-12-15 11:54:12 +03:00
public function testGroupCreateChecksShareWithGroupMembersOnlyInGroup () {
2016-02-04 14:51:23 +03:00
$share = $this -> manager -> newShare ();
2015-12-15 11:54:12 +03:00
2016-09-02 12:24:43 +03:00
$user = $this -> createMock ( IUser :: class );
$group = $this -> createMock ( IGroup :: class );
2016-02-02 23:02:09 +03:00
$share -> setSharedBy ( 'user' ) -> setSharedWith ( 'group' );
2015-12-15 11:54:12 +03:00
2016-02-02 23:02:09 +03:00
$this -> userManager -> method ( 'get' ) -> with ( 'user' ) -> willReturn ( $user );
$this -> groupManager -> method ( 'get' ) -> with ( 'group' ) -> willReturn ( $group );
$group -> method ( 'inGroup' ) -> with ( $user ) -> willReturn ( true );
2015-12-15 11:54:12 +03:00
2016-09-02 12:24:43 +03:00
$path = $this -> createMock ( Node :: class );
2016-01-27 22:51:26 +03:00
$share -> setNode ( $path );
2015-12-15 11:54:12 +03:00
$this -> defaultProvider -> method ( 'getSharesByPath' )
-> with ( $path )
-> willReturn ([]);
$this -> config
-> method ( 'getAppValue' )
2020-03-26 00:21:27 +03:00
-> willReturnMap ([
2015-12-15 11:54:12 +03:00
[ 'core' , 'shareapi_only_share_with_group_members' , 'no' , 'yes' ],
2016-03-18 18:36:27 +03:00
[ 'core' , 'shareapi_allow_group_sharing' , 'yes' , 'yes' ],
2020-03-26 00:21:27 +03:00
]);
2015-12-15 11:54:12 +03:00
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'groupCreateChecks' , [ $share ]);
2018-01-25 13:23:12 +03:00
$this -> addToAssertionCount ( 1 );
2015-12-15 11:54:12 +03:00
}
2019-12-12 23:38:52 +03:00
2015-12-15 11:54:12 +03:00
public function testGroupCreateChecksPathAlreadySharedWithSameGroup () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \Exception :: class );
$this -> expectExceptionMessage ( 'Path is already shared with this group' );
2016-01-27 22:51:26 +03:00
$share = $this -> manager -> newShare ();
2015-12-15 11:54:12 +03:00
2016-09-02 12:24:43 +03:00
$path = $this -> createMock ( Node :: class );
2016-02-02 23:02:09 +03:00
$share -> setSharedWith ( 'sharedWith' )
2016-01-27 22:51:26 +03:00
-> setNode ( $path )
2016-01-25 14:09:56 +03:00
-> setProviderId ( 'foo' )
-> setId ( 'bar' );
2015-12-15 11:54:12 +03:00
2016-02-04 14:51:23 +03:00
$share2 = $this -> manager -> newShare ();
2016-02-02 23:02:09 +03:00
$share2 -> setSharedWith ( 'sharedWith' )
2016-01-25 14:09:56 +03:00
-> setProviderId ( 'foo' )
-> setId ( 'baz' );
2015-12-15 11:54:12 +03:00
$this -> defaultProvider -> method ( 'getSharesByPath' )
-> with ( $path )
-> willReturn ([ $share2 ]);
2016-03-18 18:36:27 +03:00
$this -> config
-> method ( 'getAppValue' )
2020-03-26 00:21:27 +03:00
-> willReturnMap ([
2016-03-18 18:36:27 +03:00
[ 'core' , 'shareapi_allow_group_sharing' , 'yes' , 'yes' ],
2020-03-26 00:21:27 +03:00
]);
2016-03-18 18:36:27 +03:00
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'groupCreateChecks' , [ $share ]);
2015-12-15 11:54:12 +03:00
}
public function testGroupCreateChecksPathAlreadySharedWithDifferentGroup () {
2016-02-04 14:51:23 +03:00
$share = $this -> manager -> newShare ();
2015-12-15 11:54:12 +03:00
2016-02-02 23:02:09 +03:00
$share -> setSharedWith ( 'sharedWith' );
2015-12-15 11:54:12 +03:00
2016-09-02 12:24:43 +03:00
$path = $this -> createMock ( Node :: class );
2016-01-27 22:51:26 +03:00
$share -> setNode ( $path );
2015-12-15 11:54:12 +03:00
2016-02-04 14:51:23 +03:00
$share2 = $this -> manager -> newShare ();
2016-02-02 23:02:09 +03:00
$share2 -> setSharedWith ( 'sharedWith2' );
2015-12-15 11:54:12 +03:00
$this -> defaultProvider -> method ( 'getSharesByPath' )
-> with ( $path )
-> willReturn ([ $share2 ]);
2016-03-18 18:36:27 +03:00
$this -> config
-> method ( 'getAppValue' )
2020-03-26 00:21:27 +03:00
-> willReturnMap ([
2016-03-18 18:36:27 +03:00
[ 'core' , 'shareapi_allow_group_sharing' , 'yes' , 'yes' ],
2020-03-26 00:21:27 +03:00
]);
2016-03-18 18:36:27 +03:00
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'groupCreateChecks' , [ $share ]);
2018-01-25 13:23:12 +03:00
$this -> addToAssertionCount ( 1 );
2015-12-15 11:54:12 +03:00
}
2019-12-12 23:38:52 +03:00
2015-12-15 11:54:12 +03:00
public function testLinkCreateChecksNoLinkSharesAllowed () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \Exception :: class );
$this -> expectExceptionMessage ( 'Link sharing is not allowed' );
2016-02-04 14:51:23 +03:00
$share = $this -> manager -> newShare ();
2015-12-15 11:54:12 +03:00
$this -> config
-> method ( 'getAppValue' )
2020-03-26 00:21:27 +03:00
-> willReturnMap ([
2015-12-15 11:54:12 +03:00
[ 'core' , 'shareapi_allow_links' , 'yes' , 'no' ],
2020-03-26 00:21:27 +03:00
]);
2015-12-15 11:54:12 +03:00
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'linkCreateChecks' , [ $share ]);
2015-12-15 11:54:12 +03:00
}
2019-12-12 23:38:52 +03:00
2015-12-15 11:54:12 +03:00
public function testLinkCreateChecksNoPublicUpload () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \Exception :: class );
$this -> expectExceptionMessage ( 'Public upload is not allowed' );
2016-02-04 14:51:23 +03:00
$share = $this -> manager -> newShare ();
2015-12-15 11:54:12 +03:00
$share -> setPermissions ( \OCP\Constants :: PERMISSION_CREATE | \OCP\Constants :: PERMISSION_UPDATE );
$this -> config
-> method ( 'getAppValue' )
2020-03-26 00:21:27 +03:00
-> willReturnMap ([
2015-12-15 11:54:12 +03:00
[ 'core' , 'shareapi_allow_links' , 'yes' , 'yes' ],
[ 'core' , 'shareapi_allow_public_upload' , 'yes' , 'no' ]
2020-03-26 00:21:27 +03:00
]);
2015-12-15 11:54:12 +03:00
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'linkCreateChecks' , [ $share ]);
2015-12-15 11:54:12 +03:00
}
public function testLinkCreateChecksPublicUpload () {
2016-02-04 14:51:23 +03:00
$share = $this -> manager -> newShare ();
2015-12-15 11:54:12 +03:00
$share -> setPermissions ( \OCP\Constants :: PERMISSION_CREATE | \OCP\Constants :: PERMISSION_UPDATE );
$this -> config
-> method ( 'getAppValue' )
2020-03-26 00:21:27 +03:00
-> willReturnMap ([
2015-12-15 11:54:12 +03:00
[ 'core' , 'shareapi_allow_links' , 'yes' , 'yes' ],
[ 'core' , 'shareapi_allow_public_upload' , 'yes' , 'yes' ]
2020-03-26 00:21:27 +03:00
]);
2015-12-15 11:54:12 +03:00
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'linkCreateChecks' , [ $share ]);
2018-01-25 13:23:12 +03:00
$this -> addToAssertionCount ( 1 );
2015-12-15 11:54:12 +03:00
}
public function testLinkCreateChecksReadOnly () {
2016-02-04 14:51:23 +03:00
$share = $this -> manager -> newShare ();
2015-12-15 11:54:12 +03:00
$share -> setPermissions ( \OCP\Constants :: PERMISSION_READ );
$this -> config
-> method ( 'getAppValue' )
2020-03-26 00:21:27 +03:00
-> willReturnMap ([
2015-12-15 11:54:12 +03:00
[ 'core' , 'shareapi_allow_links' , 'yes' , 'yes' ],
[ 'core' , 'shareapi_allow_public_upload' , 'yes' , 'no' ]
2020-03-26 00:21:27 +03:00
]);
2015-12-15 11:54:12 +03:00
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'linkCreateChecks' , [ $share ]);
2018-01-25 13:23:12 +03:00
$this -> addToAssertionCount ( 1 );
2015-12-15 11:54:12 +03:00
}
2019-12-12 23:38:52 +03:00
2015-12-15 11:54:12 +03:00
public function testPathCreateChecksContainsSharedMount () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \InvalidArgumentException :: class );
$this -> expectExceptionMessage ( 'Path contains files shared with you' );
2016-09-02 12:24:43 +03:00
$path = $this -> createMock ( Folder :: class );
2015-12-15 11:54:12 +03:00
$path -> method ( 'getPath' ) -> willReturn ( 'path' );
2016-09-02 12:24:43 +03:00
$mount = $this -> createMock ( IMountPoint :: class );
$storage = $this -> createMock ( Storage :: class );
2015-12-15 11:54:12 +03:00
$mount -> method ( 'getStorage' ) -> willReturn ( $storage );
$storage -> method ( 'instanceOfStorage' ) -> with ( '\OCA\Files_Sharing\ISharedStorage' ) -> willReturn ( true );
$this -> mountManager -> method ( 'findIn' ) -> with ( 'path' ) -> willReturn ([ $mount ]);
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'pathCreateChecks' , [ $path ]);
2015-12-15 11:54:12 +03:00
}
public function testPathCreateChecksContainsNoSharedMount () {
2016-09-02 12:24:43 +03:00
$path = $this -> createMock ( Folder :: class );
2015-12-15 11:54:12 +03:00
$path -> method ( 'getPath' ) -> willReturn ( 'path' );
2016-09-02 12:24:43 +03:00
$mount = $this -> createMock ( IMountPoint :: class );
$storage = $this -> createMock ( Storage :: class );
2015-12-15 11:54:12 +03:00
$mount -> method ( 'getStorage' ) -> willReturn ( $storage );
$storage -> method ( 'instanceOfStorage' ) -> with ( '\OCA\Files_Sharing\ISharedStorage' ) -> willReturn ( false );
$this -> mountManager -> method ( 'findIn' ) -> with ( 'path' ) -> willReturn ([ $mount ]);
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'pathCreateChecks' , [ $path ]);
2018-01-25 13:23:12 +03:00
$this -> addToAssertionCount ( 1 );
2015-12-15 11:54:12 +03:00
}
public function testPathCreateChecksContainsNoFolder () {
2016-09-02 12:24:43 +03:00
$path = $this -> createMock ( File :: class );
2015-12-15 11:54:12 +03:00
2016-12-19 19:15:55 +03:00
self :: invokePrivate ( $this -> manager , 'pathCreateChecks' , [ $path ]);
2018-01-25 13:23:12 +03:00
$this -> addToAssertionCount ( 1 );
2015-12-15 11:54:12 +03:00
}
public function dataIsSharingDisabledForUser () {
$data = [];
// No exclude groups
$data [] = [ 'no' , null , null , null , false ];
// empty exclude list, user no groups
$data [] = [ 'yes' , '' , json_encode ([ '' ]), [], false ];
// empty exclude list, user groups
$data [] = [ 'yes' , '' , json_encode ([ '' ]), [ 'group1' , 'group2' ], false ];
// Convert old list to json
$data [] = [ 'yes' , 'group1,group2' , json_encode ([ 'group1' , 'group2' ]), [], false ];
// Old list partly groups in common
$data [] = [ 'yes' , 'group1,group2' , json_encode ([ 'group1' , 'group2' ]), [ 'group1' , 'group3' ], false ];
// Old list only groups in common
$data [] = [ 'yes' , 'group1,group2' , json_encode ([ 'group1' , 'group2' ]), [ 'group1' ], true ];
// New list partly in common
$data [] = [ 'yes' , json_encode ([ 'group1' , 'group2' ]), null , [ 'group1' , 'group3' ], false ];
// New list only groups in common
$data [] = [ 'yes' , json_encode ([ 'group1' , 'group2' ]), null , [ 'group2' ], true ];
return $data ;
}
/**
* @ dataProvider dataIsSharingDisabledForUser
*
* @ param string $excludeGroups
* @ param string $groupList
* @ param string $setList
* @ param string [] $groupIds
* @ param bool $expected
*/
public function testIsSharingDisabledForUser ( $excludeGroups , $groupList , $setList , $groupIds , $expected ) {
2016-09-02 12:24:43 +03:00
$user = $this -> createMock ( IUser :: class );
2015-12-15 11:54:12 +03:00
$this -> config -> method ( 'getAppValue' )
2020-03-26 00:21:27 +03:00
-> willReturnMap ([
2015-12-15 11:54:12 +03:00
[ 'core' , 'shareapi_exclude_groups' , 'no' , $excludeGroups ],
[ 'core' , 'shareapi_exclude_groups_list' , '' , $groupList ],
2020-03-26 00:21:27 +03:00
]);
2015-12-15 11:54:12 +03:00
if ( $setList !== null ) {
$this -> config -> expects ( $this -> once ())
-> method ( 'setAppValue' )
-> with ( 'core' , 'shareapi_exclude_groups_list' , $setList );
} else {
$this -> config -> expects ( $this -> never ())
-> method ( 'setAppValue' );
}
$this -> groupManager -> method ( 'getUserGroupIds' )
-> with ( $user )
-> willReturn ( $groupIds );
2016-02-02 23:02:09 +03:00
$this -> userManager -> method ( 'get' ) -> with ( 'user' ) -> willReturn ( $user );
$res = $this -> manager -> sharingDisabledForUser ( 'user' );
2015-12-15 11:54:12 +03:00
$this -> assertEquals ( $expected , $res );
}
public function dataCanShare () {
$data = [];
/*
* [ expected , sharing enabled , disabled for user ]
*/
$data [] = [ false , 'no' , false ];
$data [] = [ false , 'no' , true ];
$data [] = [ true , 'yes' , false ];
$data [] = [ false , 'yes' , true ];
return $data ;
}
/**
* @ dataProvider dataCanShare
*
* @ param bool $expected
* @ param string $sharingEnabled
* @ param bool $disabledForUser
*/
public function testCanShare ( $expected , $sharingEnabled , $disabledForUser ) {
$this -> config -> method ( 'getAppValue' )
2020-03-26 00:21:27 +03:00
-> willReturnMap ([
2015-12-15 11:54:12 +03:00
[ 'core' , 'shareapi_enabled' , 'yes' , $sharingEnabled ],
2020-03-26 00:21:27 +03:00
]);
2015-12-15 11:54:12 +03:00
2016-01-11 12:30:03 +03:00
$manager = $this -> createManagerMock ()
2016-01-27 22:51:26 +03:00
-> setMethods ([ 'sharingDisabledForUser' ])
2015-12-15 11:54:12 +03:00
-> getMock ();
2016-02-16 12:22:49 +03:00
$manager -> method ( 'sharingDisabledForUser' )
-> with ( 'user' )
-> willReturn ( $disabledForUser );
2015-12-15 11:54:12 +03:00
2016-01-27 22:51:26 +03:00
$share = $this -> manager -> newShare ();
2016-02-02 23:02:09 +03:00
$share -> setSharedBy ( 'user' );
2015-12-15 11:54:12 +03:00
2016-02-16 12:22:49 +03:00
$exception = false ;
try {
2016-12-19 19:15:55 +03:00
$res = self :: invokePrivate ( $manager , 'canShare' , [ $share ]);
2016-02-16 12:22:49 +03:00
} catch ( \Exception $e ) {
$exception = true ;
}
2015-12-15 11:54:12 +03:00
2016-02-16 12:22:49 +03:00
$this -> assertEquals ( $expected , ! $exception );
2015-12-15 11:54:12 +03:00
}
public function testCreateShareUser () {
2016-01-11 12:30:03 +03:00
$manager = $this -> createManagerMock ()
2015-12-15 11:54:12 +03:00
-> setMethods ([ 'canShare' , 'generalCreateChecks' , 'userCreateChecks' , 'pathCreateChecks' ])
-> getMock ();
2016-09-02 12:24:43 +03:00
$shareOwner = $this -> createMock ( IUser :: class );
2016-02-02 23:02:09 +03:00
$shareOwner -> method ( 'getUID' ) -> willReturn ( 'shareOwner' );
2015-12-15 11:54:12 +03:00
2016-09-02 12:24:43 +03:00
$storage = $this -> createMock ( Storage :: class );
$path = $this -> createMock ( File :: class );
2015-12-15 11:54:12 +03:00
$path -> method ( 'getOwner' ) -> willReturn ( $shareOwner );
$path -> method ( 'getName' ) -> willReturn ( 'target' );
2016-02-18 15:38:38 +03:00
$path -> method ( 'getStorage' ) -> willReturn ( $storage );
2015-12-15 11:54:12 +03:00
$share = $this -> createShare (
null ,
\OCP\Share :: SHARE_TYPE_USER ,
$path ,
2016-02-02 23:02:09 +03:00
'sharedWith' ,
'sharedBy' ,
2015-12-15 11:54:12 +03:00
null ,
\OCP\Constants :: PERMISSION_ALL );
$manager -> expects ( $this -> once ())
-> method ( 'canShare' )
-> with ( $share )
-> willReturn ( true );
$manager -> expects ( $this -> once ())
-> method ( 'generalCreateChecks' )
2020-04-10 15:19:56 +03:00
-> with ( $share );
;
2015-12-15 11:54:12 +03:00
$manager -> expects ( $this -> once ())
-> method ( 'userCreateChecks' )
2020-04-10 15:19:56 +03:00
-> with ( $share );
;
2015-12-15 11:54:12 +03:00
$manager -> expects ( $this -> once ())
-> method ( 'pathCreateChecks' )
-> with ( $path );
2016-01-13 16:21:55 +03:00
$this -> defaultProvider
2015-12-15 11:54:12 +03:00
-> expects ( $this -> once ())
-> method ( 'create' )
-> with ( $share )
2020-03-26 00:21:27 +03:00
-> willReturnArgument ( 0 );
2015-12-15 11:54:12 +03:00
$share -> expects ( $this -> once ())
-> method ( 'setShareOwner' )
2016-02-02 23:02:09 +03:00
-> with ( 'shareOwner' );
2015-12-15 11:54:12 +03:00
$share -> expects ( $this -> once ())
-> method ( 'setTarget' )
-> with ( '/target' );
$manager -> createShare ( $share );
}
public function testCreateShareGroup () {
2016-01-11 12:30:03 +03:00
$manager = $this -> createManagerMock ()
2015-12-15 11:54:12 +03:00
-> setMethods ([ 'canShare' , 'generalCreateChecks' , 'groupCreateChecks' , 'pathCreateChecks' ])
-> getMock ();
2016-09-02 12:24:43 +03:00
$shareOwner = $this -> createMock ( IUser :: class );
2016-02-02 23:02:09 +03:00
$shareOwner -> method ( 'getUID' ) -> willReturn ( 'shareOwner' );
2015-12-15 11:54:12 +03:00
2016-09-02 12:24:43 +03:00
$storage = $this -> createMock ( Storage :: class );
$path = $this -> createMock ( File :: class );
2015-12-15 11:54:12 +03:00
$path -> method ( 'getOwner' ) -> willReturn ( $shareOwner );
$path -> method ( 'getName' ) -> willReturn ( 'target' );
2016-02-18 15:38:38 +03:00
$path -> method ( 'getStorage' ) -> willReturn ( $storage );
2015-12-15 11:54:12 +03:00
$share = $this -> createShare (
null ,
\OCP\Share :: SHARE_TYPE_GROUP ,
$path ,
2016-02-02 23:02:09 +03:00
'sharedWith' ,
'sharedBy' ,
2015-12-15 11:54:12 +03:00
null ,
\OCP\Constants :: PERMISSION_ALL );
$manager -> expects ( $this -> once ())
-> method ( 'canShare' )
-> with ( $share )
-> willReturn ( true );
$manager -> expects ( $this -> once ())
-> method ( 'generalCreateChecks' )
2020-04-10 15:19:56 +03:00
-> with ( $share );
;
2015-12-15 11:54:12 +03:00
$manager -> expects ( $this -> once ())
-> method ( 'groupCreateChecks' )
2020-04-10 15:19:56 +03:00
-> with ( $share );
;
2015-12-15 11:54:12 +03:00
$manager -> expects ( $this -> once ())
-> method ( 'pathCreateChecks' )
-> with ( $path );
2016-01-13 16:21:55 +03:00
$this -> defaultProvider
2015-12-15 11:54:12 +03:00
-> expects ( $this -> once ())
-> method ( 'create' )
-> with ( $share )
2020-03-26 00:21:27 +03:00
-> willReturnArgument ( 0 );
2015-12-15 11:54:12 +03:00
$share -> expects ( $this -> once ())
-> method ( 'setShareOwner' )
2016-02-02 23:02:09 +03:00
-> with ( 'shareOwner' );
2015-12-15 11:54:12 +03:00
$share -> expects ( $this -> once ())
-> method ( 'setTarget' )
-> with ( '/target' );
$manager -> createShare ( $share );
}
public function testCreateShareLink () {
2016-01-11 12:30:03 +03:00
$manager = $this -> createManagerMock ()
2015-12-15 11:54:12 +03:00
-> setMethods ([
'canShare' ,
'generalCreateChecks' ,
'linkCreateChecks' ,
'pathCreateChecks' ,
2016-01-26 16:29:30 +03:00
'validateExpirationDate' ,
2015-12-15 11:54:12 +03:00
'verifyPassword' ,
2016-02-11 13:55:09 +03:00
'setLinkParent' ,
2015-12-15 11:54:12 +03:00
])
-> getMock ();
2016-09-02 12:24:43 +03:00
$shareOwner = $this -> createMock ( IUser :: class );
2016-02-02 23:02:09 +03:00
$shareOwner -> method ( 'getUID' ) -> willReturn ( 'shareOwner' );
2015-12-15 11:54:12 +03:00
2016-09-02 12:24:43 +03:00
$storage = $this -> createMock ( Storage :: class );
$path = $this -> createMock ( File :: class );
2015-12-15 11:54:12 +03:00
$path -> method ( 'getOwner' ) -> willReturn ( $shareOwner );
$path -> method ( 'getName' ) -> willReturn ( 'target' );
$path -> method ( 'getId' ) -> willReturn ( 1 );
2016-02-18 15:38:38 +03:00
$path -> method ( 'getStorage' ) -> willReturn ( $storage );
2015-12-15 11:54:12 +03:00
$date = new \DateTime ();
2016-01-30 01:04:42 +03:00
$share = $this -> manager -> newShare ();
2016-01-25 14:09:56 +03:00
$share -> setShareType ( \OCP\Share :: SHARE_TYPE_LINK )
2016-01-27 22:51:26 +03:00
-> setNode ( $path )
2016-02-02 23:02:09 +03:00
-> setSharedBy ( 'sharedBy' )
2016-01-25 14:09:56 +03:00
-> setPermissions ( \OCP\Constants :: PERMISSION_ALL )
-> setExpirationDate ( $date )
-> setPassword ( 'password' );
2015-12-15 11:54:12 +03:00
$manager -> expects ( $this -> once ())
-> method ( 'canShare' )
-> with ( $share )
-> willReturn ( true );
$manager -> expects ( $this -> once ())
-> method ( 'generalCreateChecks' )
2020-04-10 15:19:56 +03:00
-> with ( $share );
;
2015-12-15 11:54:12 +03:00
$manager -> expects ( $this -> once ())
-> method ( 'linkCreateChecks' )
2020-04-10 15:19:56 +03:00
-> with ( $share );
;
2015-12-15 11:54:12 +03:00
$manager -> expects ( $this -> once ())
-> method ( 'pathCreateChecks' )
-> with ( $path );
$manager -> expects ( $this -> once ())
2016-01-26 16:29:30 +03:00
-> method ( 'validateExpirationDate' )
2019-11-27 16:51:14 +03:00
-> with ( $share )
-> willReturn ( $share );
2015-12-15 11:54:12 +03:00
$manager -> expects ( $this -> once ())
-> method ( 'verifyPassword' )
-> with ( 'password' );
2016-02-11 13:55:09 +03:00
$manager -> expects ( $this -> once ())
-> method ( 'setLinkParent' )
-> with ( $share );
2015-12-15 11:54:12 +03:00
$this -> hasher -> expects ( $this -> once ())
-> method ( 'hash' )
-> with ( 'password' )
-> willReturn ( 'hashed' );
$this -> secureRandom -> method ( 'generate' )
-> willReturn ( 'token' );
2016-01-13 16:21:55 +03:00
$this -> defaultProvider
2015-12-15 11:54:12 +03:00
-> expects ( $this -> once ())
-> method ( 'create' )
-> with ( $share )
2020-04-09 14:53:40 +03:00
-> willReturnCallback ( function ( Share $share ) {
2016-01-25 14:09:56 +03:00
return $share -> setId ( 42 );
2020-03-26 00:21:27 +03:00
});
2015-12-15 11:54:12 +03:00
2017-08-03 16:14:29 +03:00
// Pre share
$this -> eventDispatcher -> expects ( $this -> at ( 0 ))
-> method ( 'dispatch' )
-> with (
$this -> equalTo ( 'OCP\Share::preShare' ),
2020-04-09 14:53:40 +03:00
$this -> callback ( function ( GenericEvent $e ) use ( $path , $date ) {
2017-08-03 16:14:29 +03:00
/** @var IShare $share */
$share = $e -> getSubject ();
return $share -> getShareType () === \OCP\Share :: SHARE_TYPE_LINK &&
$share -> getNode () === $path &&
$share -> getSharedBy () === 'sharedBy' &&
$share -> getPermissions () === \OCP\Constants :: PERMISSION_ALL &&
$share -> getExpirationDate () === $date &&
$share -> getPassword () === 'hashed' &&
$share -> getToken () === 'token' ;
})
);
2015-12-15 11:54:12 +03:00
2017-08-03 16:14:29 +03:00
// Post share
$this -> eventDispatcher -> expects ( $this -> at ( 1 ))
-> method ( 'dispatch' )
-> with (
$this -> equalTo ( 'OCP\Share::postShare' ),
2020-04-09 14:53:40 +03:00
$this -> callback ( function ( GenericEvent $e ) use ( $path , $date ) {
2017-08-03 16:14:29 +03:00
/** @var IShare $share */
$share = $e -> getSubject ();
return $share -> getShareType () === \OCP\Share :: SHARE_TYPE_LINK &&
$share -> getNode () === $path &&
$share -> getSharedBy () === 'sharedBy' &&
$share -> getPermissions () === \OCP\Constants :: PERMISSION_ALL &&
$share -> getExpirationDate () === $date &&
$share -> getPassword () === 'hashed' &&
$share -> getToken () === 'token' &&
$share -> getId () === '42' &&
$share -> getTarget () === '/target' ;
})
);
2015-12-15 11:54:12 +03:00
2016-01-25 14:09:56 +03:00
/** @var IShare $share */
$share = $manager -> createShare ( $share );
2016-02-02 23:02:09 +03:00
$this -> assertSame ( 'shareOwner' , $share -> getShareOwner ());
2016-01-25 14:09:56 +03:00
$this -> assertEquals ( '/target' , $share -> getTarget ());
$this -> assertSame ( $date , $share -> getExpirationDate ());
$this -> assertEquals ( 'token' , $share -> getToken ());
$this -> assertEquals ( 'hashed' , $share -> getPassword ());
2015-12-15 11:54:12 +03:00
}
2017-01-04 15:33:09 +03:00
public function testCreateShareMail () {
$manager = $this -> createManagerMock ()
-> setMethods ([
'canShare' ,
'generalCreateChecks' ,
'linkCreateChecks' ,
'pathCreateChecks' ,
'validateExpirationDate' ,
'verifyPassword' ,
'setLinkParent' ,
])
-> getMock ();
$shareOwner = $this -> createMock ( IUser :: class );
$shareOwner -> method ( 'getUID' ) -> willReturn ( 'shareOwner' );
$storage = $this -> createMock ( Storage :: class );
$path = $this -> createMock ( File :: class );
$path -> method ( 'getOwner' ) -> willReturn ( $shareOwner );
$path -> method ( 'getName' ) -> willReturn ( 'target' );
$path -> method ( 'getId' ) -> willReturn ( 1 );
$path -> method ( 'getStorage' ) -> willReturn ( $storage );
$share = $this -> manager -> newShare ();
$share -> setShareType ( \OCP\Share :: SHARE_TYPE_EMAIL )
-> setNode ( $path )
-> setSharedBy ( 'sharedBy' )
-> setPermissions ( \OCP\Constants :: PERMISSION_ALL );
$manager -> expects ( $this -> once ())
-> method ( 'canShare' )
-> with ( $share )
-> willReturn ( true );
$manager -> expects ( $this -> once ())
-> method ( 'generalCreateChecks' )
2020-04-10 15:19:56 +03:00
-> with ( $share );
;
2017-01-04 15:33:09 +03:00
$manager -> expects ( $this -> never ())
-> method ( 'linkCreateChecks' );
$manager -> expects ( $this -> once ())
-> method ( 'pathCreateChecks' )
-> with ( $path );
$manager -> expects ( $this -> never ())
-> method ( 'validateExpirationDate' );
$manager -> expects ( $this -> never ())
-> method ( 'verifyPassword' );
$manager -> expects ( $this -> never ())
-> method ( 'setLinkParent' );
$this -> secureRandom -> method ( 'generate' )
-> willReturn ( 'token' );
$this -> defaultProvider
-> expects ( $this -> once ())
-> method ( 'create' )
-> with ( $share )
2020-04-09 14:53:40 +03:00
-> willReturnCallback ( function ( Share $share ) {
2017-01-04 15:33:09 +03:00
return $share -> setId ( 42 );
2020-03-26 00:21:27 +03:00
});
2017-01-04 15:33:09 +03:00
2017-08-03 16:14:29 +03:00
// Pre share
$this -> eventDispatcher -> expects ( $this -> at ( 0 ))
-> method ( 'dispatch' )
-> with (
$this -> equalTo ( 'OCP\Share::preShare' ),
2020-04-09 14:53:40 +03:00
$this -> callback ( function ( GenericEvent $e ) use ( $path ) {
2017-08-03 16:14:29 +03:00
/** @var IShare $share */
$share = $e -> getSubject ();
return $share -> getShareType () === \OCP\Share :: SHARE_TYPE_EMAIL &&
$share -> getNode () === $path &&
$share -> getSharedBy () === 'sharedBy' &&
$share -> getPermissions () === \OCP\Constants :: PERMISSION_ALL &&
$share -> getExpirationDate () === null &&
$share -> getPassword () === null &&
$share -> getToken () === 'token' ;
})
);
2017-01-04 15:33:09 +03:00
2017-08-03 16:14:29 +03:00
// Post share
$this -> eventDispatcher -> expects ( $this -> at ( 1 ))
-> method ( 'dispatch' )
-> with (
$this -> equalTo ( 'OCP\Share::postShare' ),
2020-04-09 14:53:40 +03:00
$this -> callback ( function ( GenericEvent $e ) use ( $path ) {
2017-08-03 16:14:29 +03:00
/** @var IShare $share */
$share = $e -> getSubject ();
return $share -> getShareType () === \OCP\Share :: SHARE_TYPE_EMAIL &&
$share -> getNode () === $path &&
$share -> getSharedBy () === 'sharedBy' &&
$share -> getPermissions () === \OCP\Constants :: PERMISSION_ALL &&
$share -> getExpirationDate () === null &&
$share -> getPassword () === null &&
$share -> getToken () === 'token' &&
$share -> getId () === '42' &&
$share -> getTarget () === '/target' ;
})
);
2017-01-04 15:33:09 +03:00
/** @var IShare $share */
$share = $manager -> createShare ( $share );
$this -> assertSame ( 'shareOwner' , $share -> getShareOwner ());
$this -> assertEquals ( '/target' , $share -> getTarget ());
$this -> assertEquals ( 'token' , $share -> getToken ());
}
2019-12-12 23:38:52 +03:00
2015-12-15 11:54:12 +03:00
public function testCreateShareHookError () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \Exception :: class );
$this -> expectExceptionMessage ( 'I won\'t let you share' );
2016-01-11 12:30:03 +03:00
$manager = $this -> createManagerMock ()
2015-12-15 11:54:12 +03:00
-> setMethods ([
'canShare' ,
'generalCreateChecks' ,
'userCreateChecks' ,
'pathCreateChecks' ,
])
-> getMock ();
2016-09-02 12:24:43 +03:00
$shareOwner = $this -> createMock ( IUser :: class );
2016-02-02 23:02:09 +03:00
$shareOwner -> method ( 'getUID' ) -> willReturn ( 'shareOwner' );
2015-12-15 11:54:12 +03:00
2016-09-02 12:24:43 +03:00
$storage = $this -> createMock ( Storage :: class );
$path = $this -> createMock ( File :: class );
2015-12-15 11:54:12 +03:00
$path -> method ( 'getOwner' ) -> willReturn ( $shareOwner );
$path -> method ( 'getName' ) -> willReturn ( 'target' );
2016-02-18 15:38:38 +03:00
$path -> method ( 'getStorage' ) -> willReturn ( $storage );
2015-12-15 11:54:12 +03:00
$share = $this -> createShare (
null ,
\OCP\Share :: SHARE_TYPE_USER ,
$path ,
2016-02-02 23:02:09 +03:00
'sharedWith' ,
'sharedBy' ,
2015-12-15 11:54:12 +03:00
null ,
\OCP\Constants :: PERMISSION_ALL );
$manager -> expects ( $this -> once ())
-> method ( 'canShare' )
-> with ( $share )
-> willReturn ( true );
$manager -> expects ( $this -> once ())
-> method ( 'generalCreateChecks' )
2020-04-10 15:19:56 +03:00
-> with ( $share );
;
2015-12-15 11:54:12 +03:00
$manager -> expects ( $this -> once ())
-> method ( 'userCreateChecks' )
2020-04-10 15:19:56 +03:00
-> with ( $share );
;
2015-12-15 11:54:12 +03:00
$manager -> expects ( $this -> once ())
-> method ( 'pathCreateChecks' )
-> with ( $path );
$share -> expects ( $this -> once ())
-> method ( 'setShareOwner' )
2016-02-02 23:02:09 +03:00
-> with ( 'shareOwner' );
2015-12-15 11:54:12 +03:00
$share -> expects ( $this -> once ())
-> method ( 'setTarget' )
-> with ( '/target' );
2017-08-03 16:14:29 +03:00
// Pre share
$this -> eventDispatcher -> expects ( $this -> once ())
-> method ( 'dispatch' )
-> with (
$this -> equalTo ( 'OCP\Share::preShare' ),
$this -> isInstanceOf ( GenericEvent :: class )
2020-04-09 14:53:40 +03:00
) -> willReturnCallback ( function ( $name , GenericEvent $e ) {
2020-04-10 15:19:56 +03:00
$e -> setArgument ( 'error' , 'I won\'t let you share!' );
$e -> stopPropagation ();
}
2017-08-03 16:14:29 +03:00
);
2016-02-18 15:38:38 +03:00
$manager -> createShare ( $share );
}
2018-12-05 13:27:38 +03:00
public function testCreateShareOfIncomingFederatedShare () {
2016-02-18 15:38:38 +03:00
$manager = $this -> createManagerMock ()
-> setMethods ([ 'canShare' , 'generalCreateChecks' , 'userCreateChecks' , 'pathCreateChecks' ])
-> getMock ();
2016-09-02 12:24:43 +03:00
$shareOwner = $this -> createMock ( IUser :: class );
2016-02-18 15:38:38 +03:00
$shareOwner -> method ( 'getUID' ) -> willReturn ( 'shareOwner' );
2016-09-02 12:24:43 +03:00
$storage = $this -> createMock ( Storage :: class );
2016-02-18 15:38:38 +03:00
$storage -> method ( 'instanceOfStorage' )
-> with ( 'OCA\Files_Sharing\External\Storage' )
-> willReturn ( true );
2016-09-02 12:24:43 +03:00
$storage2 = $this -> createMock ( Storage :: class );
2016-02-18 15:38:38 +03:00
$storage2 -> method ( 'instanceOfStorage' )
-> with ( 'OCA\Files_Sharing\External\Storage' )
-> willReturn ( false );
2016-09-02 12:24:43 +03:00
$path = $this -> createMock ( File :: class );
2016-02-18 15:38:38 +03:00
$path -> expects ( $this -> never ()) -> method ( 'getOwner' );
$path -> method ( 'getName' ) -> willReturn ( 'target' );
$path -> method ( 'getStorage' ) -> willReturn ( $storage );
2016-09-02 12:24:43 +03:00
$parent = $this -> createMock ( Folder :: class );
2016-02-18 15:38:38 +03:00
$parent -> method ( 'getStorage' ) -> willReturn ( $storage );
2016-09-02 12:24:43 +03:00
$parentParent = $this -> createMock ( Folder :: class );
2016-02-18 15:38:38 +03:00
$parentParent -> method ( 'getStorage' ) -> willReturn ( $storage2 );
$parentParent -> method ( 'getOwner' ) -> willReturn ( $shareOwner );
$path -> method ( 'getParent' ) -> willReturn ( $parent );
$parent -> method ( 'getParent' ) -> willReturn ( $parentParent );
$share = $this -> createShare (
null ,
\OCP\Share :: SHARE_TYPE_USER ,
$path ,
'sharedWith' ,
'sharedBy' ,
null ,
\OCP\Constants :: PERMISSION_ALL );
$manager -> expects ( $this -> once ())
-> method ( 'canShare' )
-> with ( $share )
-> willReturn ( true );
$manager -> expects ( $this -> once ())
-> method ( 'generalCreateChecks' )
2020-04-10 15:19:56 +03:00
-> with ( $share );
;
2016-02-18 15:38:38 +03:00
$manager -> expects ( $this -> once ())
-> method ( 'userCreateChecks' )
2020-04-10 15:19:56 +03:00
-> with ( $share );
;
2016-02-18 15:38:38 +03:00
$manager -> expects ( $this -> once ())
-> method ( 'pathCreateChecks' )
-> with ( $path );
$this -> defaultProvider
-> expects ( $this -> once ())
-> method ( 'create' )
-> with ( $share )
2020-03-26 00:21:27 +03:00
-> willReturnArgument ( 0 );
2016-02-18 15:38:38 +03:00
$share -> expects ( $this -> once ())
-> method ( 'setShareOwner' )
-> with ( 'shareOwner' );
$share -> expects ( $this -> once ())
-> method ( 'setTarget' )
-> with ( '/target' );
2015-12-15 11:54:12 +03:00
$manager -> createShare ( $share );
}
2016-01-20 23:56:55 +03:00
2016-02-05 22:00:07 +03:00
public function testGetSharesBy () {
$share = $this -> manager -> newShare ();
2016-09-02 12:24:43 +03:00
$node = $this -> createMock ( Folder :: class );
2016-02-05 22:00:07 +03:00
$this -> defaultProvider -> expects ( $this -> once ())
-> method ( 'getSharesBy' )
-> with (
$this -> equalTo ( 'user' ),
$this -> equalTo ( \OCP\Share :: SHARE_TYPE_USER ),
$this -> equalTo ( $node ),
$this -> equalTo ( true ),
$this -> equalTo ( 1 ),
$this -> equalTo ( 1 )
) -> willReturn ([ $share ]);
$shares = $this -> manager -> getSharesBy ( 'user' , \OCP\Share :: SHARE_TYPE_USER , $node , true , 1 , 1 );
$this -> assertCount ( 1 , $shares );
$this -> assertSame ( $share , $shares [ 0 ]);
}
/**
* Test to ensure we correctly remove expired link shares
*
* We have 8 Shares and we want the 3 first valid shares .
* share 3 - 6 and 8 are expired . Thus at the end of this test we should
* have received share 1 , 2 and 7. And from the manager . Share 3 - 6 should be
* deleted ( as they are evaluated ) . but share 8 should still be there .
*/
public function testGetSharesByExpiredLinkShares () {
$manager = $this -> createManagerMock ()
-> setMethods ([ 'deleteShare' ])
-> getMock ();
/** @var \OCP\Share\IShare[] $shares */
$shares = [];
/*
* This results in an array of 8 IShare elements
*/
for ( $i = 0 ; $i < 8 ; $i ++ ) {
$share = $this -> manager -> newShare ();
$share -> setId ( $i );
$shares [] = $share ;
}
$today = new \DateTime ();
$today -> setTime ( 0 , 0 , 0 );
/*
* Set the expiration date to today for some shares
*/
$shares [ 2 ] -> setExpirationDate ( $today );
$shares [ 3 ] -> setExpirationDate ( $today );
$shares [ 4 ] -> setExpirationDate ( $today );
$shares [ 5 ] -> setExpirationDate ( $today );
/** @var \OCP\Share\IShare[] $i */
$shares2 = [];
for ( $i = 0 ; $i < 8 ; $i ++ ) {
$shares2 [] = clone $shares [ $i ];
}
2016-09-02 12:24:43 +03:00
$node = $this -> createMock ( File :: class );
2016-02-05 22:00:07 +03:00
/*
* Simulate the getSharesBy call .
*/
$this -> defaultProvider
-> method ( 'getSharesBy' )
2020-04-09 14:53:40 +03:00
-> willReturnCallback ( function ( $uid , $type , $node , $reshares , $limit , $offset ) use ( & $shares2 ) {
2016-02-05 22:00:07 +03:00
return array_slice ( $shares2 , $offset , $limit );
2020-03-26 00:21:27 +03:00
});
2016-02-05 22:00:07 +03:00
/*
* Simulate the deleteShare call .
*/
$manager -> method ( 'deleteShare' )
2020-04-09 14:53:40 +03:00
-> willReturnCallback ( function ( $share ) use ( & $shares2 ) {
2020-04-10 15:19:56 +03:00
for ( $i = 0 ; $i < count ( $shares2 ); $i ++ ) {
2016-02-05 22:00:07 +03:00
if ( $shares2 [ $i ] -> getId () === $share -> getId ()) {
array_splice ( $shares2 , $i , 1 );
break ;
}
}
2020-03-26 00:21:27 +03:00
});
2016-02-05 22:00:07 +03:00
$res = $manager -> getSharesBy ( 'user' , \OCP\Share :: SHARE_TYPE_LINK , $node , true , 3 , 0 );
$this -> assertCount ( 3 , $res );
$this -> assertEquals ( $shares [ 0 ] -> getId (), $res [ 0 ] -> getId ());
$this -> assertEquals ( $shares [ 1 ] -> getId (), $res [ 1 ] -> getId ());
$this -> assertEquals ( $shares [ 6 ] -> getId (), $res [ 2 ] -> getId ());
$this -> assertCount ( 4 , $shares2 );
$this -> assertEquals ( 0 , $shares2 [ 0 ] -> getId ());
$this -> assertEquals ( 1 , $shares2 [ 1 ] -> getId ());
$this -> assertEquals ( 6 , $shares2 [ 2 ] -> getId ());
$this -> assertEquals ( 7 , $shares2 [ 3 ] -> getId ());
$this -> assertSame ( $today , $shares [ 3 ] -> getExpirationDate ());
}
2016-01-20 23:56:55 +03:00
public function testGetShareByToken () {
2016-12-19 19:15:55 +03:00
$this -> config
-> expects ( $this -> once ())
-> method ( 'getAppValue' )
-> with ( 'core' , 'shareapi_allow_links' , 'yes' )
-> willReturn ( 'yes' );
2016-09-02 12:24:43 +03:00
$factory = $this -> createMock ( IProviderFactory :: class );
2016-01-20 23:56:55 +03:00
$manager = new Manager (
$this -> logger ,
$this -> config ,
$this -> secureRandom ,
$this -> hasher ,
$this -> mountManager ,
$this -> groupManager ,
$this -> l ,
2017-09-08 11:34:19 +03:00
$this -> l10nFactory ,
2016-02-02 23:02:09 +03:00
$factory ,
2016-02-04 14:51:23 +03:00
$this -> userManager ,
2016-06-24 18:53:37 +03:00
$this -> rootFolder ,
2017-07-27 00:53:07 +03:00
$this -> eventDispatcher ,
$this -> mailer ,
$this -> urlGenerator ,
2019-12-12 23:38:52 +03:00
$this -> defaults ,
$this -> dispatcher
2016-01-20 23:56:55 +03:00
);
2016-09-02 12:24:43 +03:00
$share = $this -> createMock ( IShare :: class );
2016-01-20 23:56:55 +03:00
$factory -> expects ( $this -> once ())
-> method ( 'getProviderForType' )
-> with ( \OCP\Share :: SHARE_TYPE_LINK )
-> willReturn ( $this -> defaultProvider );
$this -> defaultProvider -> expects ( $this -> once ())
-> method ( 'getShareByToken' )
-> with ( 'token' )
-> willReturn ( $share );
$ret = $manager -> getShareByToken ( 'token' );
$this -> assertSame ( $share , $ret );
}
2018-08-01 20:04:32 +03:00
public function testGetShareByTokenRoom () {
$this -> config
-> expects ( $this -> once ())
-> method ( 'getAppValue' )
-> with ( 'core' , 'shareapi_allow_links' , 'yes' )
-> willReturn ( 'no' );
$factory = $this -> createMock ( IProviderFactory :: class );
$manager = new Manager (
$this -> logger ,
$this -> config ,
$this -> secureRandom ,
$this -> hasher ,
$this -> mountManager ,
$this -> groupManager ,
$this -> l ,
$this -> l10nFactory ,
$factory ,
$this -> userManager ,
$this -> rootFolder ,
$this -> eventDispatcher ,
$this -> mailer ,
$this -> urlGenerator ,
2019-12-12 23:38:52 +03:00
$this -> defaults ,
$this -> dispatcher
2018-08-01 20:04:32 +03:00
);
$share = $this -> createMock ( IShare :: class );
$roomShareProvider = $this -> createMock ( IShareProvider :: class );
$factory -> expects ( $this -> any ())
-> method ( 'getProviderForType' )
2020-04-09 14:53:40 +03:00
-> willReturnCallback ( function ( $shareType ) use ( $roomShareProvider ) {
2018-08-01 20:04:32 +03:00
if ( $shareType !== \OCP\Share :: SHARE_TYPE_ROOM ) {
throw new Exception\ProviderException ();
}
return $roomShareProvider ;
2020-03-26 00:21:27 +03:00
});
2018-08-01 20:04:32 +03:00
$roomShareProvider -> expects ( $this -> once ())
-> method ( 'getShareByToken' )
-> with ( 'token' )
-> willReturn ( $share );
$ret = $manager -> getShareByToken ( 'token' );
$this -> assertSame ( $share , $ret );
}
2016-04-12 22:32:40 +03:00
public function testGetShareByTokenWithException () {
2016-12-19 19:15:55 +03:00
$this -> config
-> expects ( $this -> once ())
-> method ( 'getAppValue' )
-> with ( 'core' , 'shareapi_allow_links' , 'yes' )
-> willReturn ( 'yes' );
2016-09-02 12:24:43 +03:00
$factory = $this -> createMock ( IProviderFactory :: class );
2016-04-12 22:32:40 +03:00
$manager = new Manager (
$this -> logger ,
$this -> config ,
$this -> secureRandom ,
$this -> hasher ,
$this -> mountManager ,
$this -> groupManager ,
$this -> l ,
2017-09-08 11:34:19 +03:00
$this -> l10nFactory ,
2016-04-12 22:32:40 +03:00
$factory ,
$this -> userManager ,
2016-06-24 18:53:37 +03:00
$this -> rootFolder ,
2017-07-27 00:53:07 +03:00
$this -> eventDispatcher ,
$this -> mailer ,
$this -> urlGenerator ,
2019-12-12 23:38:52 +03:00
$this -> defaults ,
$this -> dispatcher
2016-04-12 22:32:40 +03:00
);
2016-09-02 12:24:43 +03:00
$share = $this -> createMock ( IShare :: class );
2016-04-12 22:32:40 +03:00
$factory -> expects ( $this -> at ( 0 ))
-> method ( 'getProviderForType' )
-> with ( \OCP\Share :: SHARE_TYPE_LINK )
-> willReturn ( $this -> defaultProvider );
$factory -> expects ( $this -> at ( 1 ))
-> method ( 'getProviderForType' )
-> with ( \OCP\Share :: SHARE_TYPE_REMOTE )
-> willReturn ( $this -> defaultProvider );
$this -> defaultProvider -> expects ( $this -> at ( 0 ))
-> method ( 'getShareByToken' )
-> with ( 'token' )
-> will ( $this -> throwException ( new ShareNotFound ()));
$this -> defaultProvider -> expects ( $this -> at ( 1 ))
-> method ( 'getShareByToken' )
-> with ( 'token' )
-> willReturn ( $share );
$ret = $manager -> getShareByToken ( 'token' );
$this -> assertSame ( $share , $ret );
}
2019-12-12 23:38:52 +03:00
2016-02-05 14:59:46 +03:00
public function testGetShareByTokenExpired () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \OCP\Share\Exceptions\ShareNotFound :: class );
$this -> expectExceptionMessage ( 'The requested share does not exist anymore' );
2016-12-19 19:15:55 +03:00
$this -> config
-> expects ( $this -> once ())
-> method ( 'getAppValue' )
-> with ( 'core' , 'shareapi_allow_links' , 'yes' )
-> willReturn ( 'yes' );
2017-06-13 19:44:14 +03:00
$this -> l -> expects ( $this -> once ())
-> method ( 't' )
-> willReturnArgument ( 0 );
2016-02-05 14:59:46 +03:00
$manager = $this -> createManagerMock ()
-> setMethods ([ 'deleteShare' ])
-> getMock ();
$date = new \DateTime ();
$date -> setTime ( 0 , 0 , 0 );
$share = $this -> manager -> newShare ();
$share -> setExpirationDate ( $date );
$this -> defaultProvider -> expects ( $this -> once ())
-> method ( 'getShareByToken' )
-> with ( 'expiredToken' )
-> willReturn ( $share );
$manager -> expects ( $this -> once ())
-> method ( 'deleteShare' )
-> with ( $this -> equalTo ( $share ));
$manager -> getShareByToken ( 'expiredToken' );
}
public function testGetShareByTokenNotExpired () {
2016-12-19 19:15:55 +03:00
$this -> config
-> expects ( $this -> once ())
-> method ( 'getAppValue' )
-> with ( 'core' , 'shareapi_allow_links' , 'yes' )
-> willReturn ( 'yes' );
2016-02-05 14:59:46 +03:00
$date = new \DateTime ();
$date -> setTime ( 0 , 0 , 0 );
$date -> add ( new \DateInterval ( 'P2D' ));
$share = $this -> manager -> newShare ();
$share -> setExpirationDate ( $date );
$this -> defaultProvider -> expects ( $this -> once ())
-> method ( 'getShareByToken' )
-> with ( 'expiredToken' )
-> willReturn ( $share );
$res = $this -> manager -> getShareByToken ( 'expiredToken' );
$this -> assertSame ( $share , $res );
}
2019-12-12 23:38:52 +03:00
2016-12-19 19:15:55 +03:00
public function testGetShareByTokenWithPublicLinksDisabled () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \OCP\Share\Exceptions\ShareNotFound :: class );
2016-12-19 19:15:55 +03:00
$this -> config
-> expects ( $this -> once ())
-> method ( 'getAppValue' )
-> with ( 'core' , 'shareapi_allow_links' , 'yes' )
-> willReturn ( 'no' );
$this -> manager -> getShareByToken ( 'validToken' );
}
public function testGetShareByTokenPublicUploadDisabled () {
$this -> config
-> expects ( $this -> at ( 0 ))
-> method ( 'getAppValue' )
-> with ( 'core' , 'shareapi_allow_links' , 'yes' )
-> willReturn ( 'yes' );
2016-04-01 18:02:59 +03:00
$share = $this -> manager -> newShare ();
$share -> setShareType ( \OCP\Share :: SHARE_TYPE_LINK )
-> setPermissions ( \OCP\Constants :: PERMISSION_READ | \OCP\Constants :: PERMISSION_CREATE | \OCP\Constants :: PERMISSION_UPDATE );
2016-12-19 19:15:55 +03:00
$this -> config
-> expects ( $this -> at ( 1 ))
-> method ( 'getAppValue' )
2020-03-26 00:21:27 +03:00
-> willReturnMap ([
2020-04-09 10:22:29 +03:00
[ 'core' , 'shareapi_allow_public_upload' , 'yes' , 'no' ],
]);
2016-04-01 18:02:59 +03:00
$this -> defaultProvider -> expects ( $this -> once ())
-> method ( 'getShareByToken' )
-> willReturn ( 'validToken' )
-> willReturn ( $share );
$res = $this -> manager -> getShareByToken ( 'validToken' );
$this -> assertSame ( \OCP\Constants :: PERMISSION_READ , $res -> getPermissions ());
}
2016-01-20 23:56:55 +03:00
public function testCheckPasswordNoLinkShare () {
2016-09-02 12:24:43 +03:00
$share = $this -> createMock ( IShare :: class );
2016-01-20 23:56:55 +03:00
$share -> method ( 'getShareType' ) -> willReturn ( \OCP\Share :: SHARE_TYPE_USER );
$this -> assertFalse ( $this -> manager -> checkPassword ( $share , 'password' ));
}
public function testCheckPasswordNoPassword () {
2016-09-02 12:24:43 +03:00
$share = $this -> createMock ( IShare :: class );
2016-01-20 23:56:55 +03:00
$share -> method ( 'getShareType' ) -> willReturn ( \OCP\Share :: SHARE_TYPE_LINK );
$this -> assertFalse ( $this -> manager -> checkPassword ( $share , 'password' ));
$share -> method ( 'getPassword' ) -> willReturn ( 'password' );
$this -> assertFalse ( $this -> manager -> checkPassword ( $share , null ));
}
public function testCheckPasswordInvalidPassword () {
2016-09-02 12:24:43 +03:00
$share = $this -> createMock ( IShare :: class );
2016-01-20 23:56:55 +03:00
$share -> method ( 'getShareType' ) -> willReturn ( \OCP\Share :: SHARE_TYPE_LINK );
$share -> method ( 'getPassword' ) -> willReturn ( 'password' );
$this -> hasher -> method ( 'verify' ) -> with ( 'invalidpassword' , 'password' , '' ) -> willReturn ( false );
$this -> assertFalse ( $this -> manager -> checkPassword ( $share , 'invalidpassword' ));
}
public function testCheckPasswordValidPassword () {
2016-09-02 12:24:43 +03:00
$share = $this -> createMock ( IShare :: class );
2016-01-20 23:56:55 +03:00
$share -> method ( 'getShareType' ) -> willReturn ( \OCP\Share :: SHARE_TYPE_LINK );
$share -> method ( 'getPassword' ) -> willReturn ( 'passwordHash' );
$this -> hasher -> method ( 'verify' ) -> with ( 'password' , 'passwordHash' , '' ) -> willReturn ( true );
$this -> assertTrue ( $this -> manager -> checkPassword ( $share , 'password' ));
}
2016-01-25 15:09:50 +03:00
2016-02-01 23:46:32 +03:00
public function testCheckPasswordUpdateShare () {
$share = $this -> manager -> newShare ();
$share -> setShareType ( \OCP\Share :: SHARE_TYPE_LINK )
-> setPassword ( 'passwordHash' );
$this -> hasher -> method ( 'verify' ) -> with ( 'password' , 'passwordHash' , '' )
2020-04-09 14:53:40 +03:00
-> willReturnCallback ( function ( $pass , $hash , & $newHash ) {
2016-02-01 23:46:32 +03:00
$newHash = 'newHash' ;
return true ;
2020-03-26 00:21:27 +03:00
});
2016-02-01 23:46:32 +03:00
$this -> defaultProvider -> expects ( $this -> once ())
-> method ( 'update' )
-> with ( $this -> callback ( function ( \OCP\Share\IShare $share ) {
return $share -> getPassword () === 'newHash' ;
}));
$this -> assertTrue ( $this -> manager -> checkPassword ( $share , 'password' ));
}
2019-12-12 23:38:52 +03:00
2016-01-25 15:09:50 +03:00
public function testUpdateShareCantChangeShareType () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \Exception :: class );
$this -> expectExceptionMessage ( 'Can’ t change share type' );
2016-01-25 15:09:50 +03:00
$manager = $this -> createManagerMock ()
-> setMethods ([
'canShare' ,
'getShareById'
])
-> getMock ();
2016-02-04 14:51:23 +03:00
$originalShare = $this -> manager -> newShare ();
2016-01-25 15:09:50 +03:00
$originalShare -> setShareType ( \OCP\Share :: SHARE_TYPE_GROUP );
$manager -> expects ( $this -> once ()) -> method ( 'canShare' ) -> willReturn ( true );
$manager -> expects ( $this -> once ()) -> method ( 'getShareById' ) -> with ( 'foo:42' ) -> willReturn ( $originalShare );
2016-02-04 14:51:23 +03:00
$share = $this -> manager -> newShare ();
2016-01-25 15:09:50 +03:00
$share -> setProviderId ( 'foo' )
-> setId ( '42' )
-> setShareType ( \OCP\Share :: SHARE_TYPE_USER );
$manager -> updateShare ( $share );
}
2019-12-12 23:38:52 +03:00
2016-01-25 15:09:50 +03:00
public function testUpdateShareCantChangeRecipientForGroupShare () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \Exception :: class );
$this -> expectExceptionMessage ( 'Can only update recipient on user shares' );
2016-01-25 15:09:50 +03:00
$manager = $this -> createManagerMock ()
-> setMethods ([
'canShare' ,
'getShareById'
])
-> getMock ();
2016-02-04 14:51:23 +03:00
$originalShare = $this -> manager -> newShare ();
2016-01-25 15:09:50 +03:00
$originalShare -> setShareType ( \OCP\Share :: SHARE_TYPE_GROUP )
2016-02-02 23:02:09 +03:00
-> setSharedWith ( 'origGroup' );
2016-01-25 15:09:50 +03:00
$manager -> expects ( $this -> once ()) -> method ( 'canShare' ) -> willReturn ( true );
$manager -> expects ( $this -> once ()) -> method ( 'getShareById' ) -> with ( 'foo:42' ) -> willReturn ( $originalShare );
2016-02-04 14:51:23 +03:00
$share = $this -> manager -> newShare ();
2016-01-25 15:09:50 +03:00
$share -> setProviderId ( 'foo' )
-> setId ( '42' )
-> setShareType ( \OCP\Share :: SHARE_TYPE_GROUP )
2016-02-02 23:02:09 +03:00
-> setSharedWith ( 'newGroup' );
2016-01-25 15:09:50 +03:00
$manager -> updateShare ( $share );
}
2019-12-12 23:38:52 +03:00
2016-01-25 15:09:50 +03:00
public function testUpdateShareCantShareWithOwner () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \Exception :: class );
$this -> expectExceptionMessage ( 'Can’ t share with the share owner' );
2016-01-25 15:09:50 +03:00
$manager = $this -> createManagerMock ()
-> setMethods ([
'canShare' ,
'getShareById'
])
-> getMock ();
2016-02-04 14:51:23 +03:00
$originalShare = $this -> manager -> newShare ();
2016-01-25 15:09:50 +03:00
$originalShare -> setShareType ( \OCP\Share :: SHARE_TYPE_USER )
2016-02-02 23:02:09 +03:00
-> setSharedWith ( 'sharedWith' );
2016-01-25 15:09:50 +03:00
$manager -> expects ( $this -> once ()) -> method ( 'canShare' ) -> willReturn ( true );
$manager -> expects ( $this -> once ()) -> method ( 'getShareById' ) -> with ( 'foo:42' ) -> willReturn ( $originalShare );
2016-02-04 14:51:23 +03:00
$share = $this -> manager -> newShare ();
2016-01-25 15:09:50 +03:00
$share -> setProviderId ( 'foo' )
-> setId ( '42' )
-> setShareType ( \OCP\Share :: SHARE_TYPE_USER )
2016-02-02 23:02:09 +03:00
-> setSharedWith ( 'newUser' )
-> setShareOwner ( 'newUser' );
2016-01-25 15:09:50 +03:00
$manager -> updateShare ( $share );
}
public function testUpdateShareUser () {
2016-05-11 21:48:27 +03:00
$this -> userManager -> expects ( $this -> any ()) -> method ( 'userExists' ) -> willReturn ( true );
2016-01-25 15:09:50 +03:00
$manager = $this -> createManagerMock ()
-> setMethods ([
'canShare' ,
'getShareById' ,
'generalCreateChecks' ,
'userCreateChecks' ,
'pathCreateChecks' ,
])
-> getMock ();
2016-02-04 14:51:23 +03:00
$originalShare = $this -> manager -> newShare ();
2016-01-25 15:09:50 +03:00
$originalShare -> setShareType ( \OCP\Share :: SHARE_TYPE_USER )
2016-02-04 11:53:47 +03:00
-> setSharedWith ( 'origUser' )
-> setPermissions ( 1 );
2016-09-02 12:24:43 +03:00
$node = $this -> createMock ( File :: class );
2016-02-04 11:53:47 +03:00
$node -> method ( 'getId' ) -> willReturn ( 100 );
2016-02-04 15:25:24 +03:00
$node -> method ( 'getPath' ) -> willReturn ( '/newUser/files/myPath' );
2016-01-25 15:09:50 +03:00
$manager -> expects ( $this -> once ()) -> method ( 'canShare' ) -> willReturn ( true );
$manager -> expects ( $this -> once ()) -> method ( 'getShareById' ) -> with ( 'foo:42' ) -> willReturn ( $originalShare );
2016-02-04 14:51:23 +03:00
$share = $this -> manager -> newShare ();
2016-01-25 15:09:50 +03:00
$share -> setProviderId ( 'foo' )
-> setId ( '42' )
-> setShareType ( \OCP\Share :: SHARE_TYPE_USER )
2016-02-02 23:02:09 +03:00
-> setSharedWith ( 'origUser' )
2016-02-04 14:51:23 +03:00
-> setShareOwner ( 'newUser' )
2016-02-04 11:53:47 +03:00
-> setSharedBy ( 'sharer' )
-> setPermissions ( 31 )
2016-02-04 14:51:23 +03:00
-> setNode ( $node );
2016-01-25 15:09:50 +03:00
$this -> defaultProvider -> expects ( $this -> once ())
-> method ( 'update' )
-> with ( $share )
-> willReturn ( $share );
$hookListner = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_set_expiration_date' , $hookListner , 'post' );
$hookListner -> expects ( $this -> never ()) -> method ( 'post' );
2020-03-26 00:21:27 +03:00
$this -> rootFolder -> method ( 'getUserFolder' ) -> with ( 'newUser' ) -> willReturnSelf ();
2016-02-04 15:25:24 +03:00
$this -> rootFolder -> method ( 'getRelativePath' ) -> with ( '/newUser/files/myPath' ) -> willReturn ( '/myPath' );
2016-02-04 11:53:47 +03:00
$hookListner2 = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_update_permissions' , $hookListner2 , 'post' );
$hookListner2 -> expects ( $this -> once ()) -> method ( 'post' ) -> with ([
'itemType' => 'file' ,
'itemSource' => 100 ,
'shareType' => \OCP\Share :: SHARE_TYPE_USER ,
'shareWith' => 'origUser' ,
'uidOwner' => 'sharer' ,
'permissions' => 31 ,
2016-02-04 15:25:24 +03:00
'path' => '/myPath' ,
2016-02-04 11:53:47 +03:00
]);
2016-01-25 15:09:50 +03:00
$manager -> updateShare ( $share );
}
public function testUpdateShareGroup () {
$manager = $this -> createManagerMock ()
-> setMethods ([
'canShare' ,
'getShareById' ,
'generalCreateChecks' ,
'groupCreateChecks' ,
'pathCreateChecks' ,
])
-> getMock ();
2016-02-04 14:51:23 +03:00
$originalShare = $this -> manager -> newShare ();
2016-01-25 15:09:50 +03:00
$originalShare -> setShareType ( \OCP\Share :: SHARE_TYPE_GROUP )
2016-02-04 11:53:47 +03:00
-> setSharedWith ( 'origUser' )
-> setPermissions ( 31 );
2016-01-25 15:09:50 +03:00
$manager -> expects ( $this -> once ()) -> method ( 'canShare' ) -> willReturn ( true );
$manager -> expects ( $this -> once ()) -> method ( 'getShareById' ) -> with ( 'foo:42' ) -> willReturn ( $originalShare );
2016-09-02 12:24:43 +03:00
$node = $this -> createMock ( File :: class );
2016-02-04 14:51:23 +03:00
$share = $this -> manager -> newShare ();
2016-01-25 15:09:50 +03:00
$share -> setProviderId ( 'foo' )
-> setId ( '42' )
-> setShareType ( \OCP\Share :: SHARE_TYPE_GROUP )
2016-02-02 23:02:09 +03:00
-> setSharedWith ( 'origUser' )
2016-02-04 14:51:23 +03:00
-> setShareOwner ( 'owner' )
2016-02-04 11:53:47 +03:00
-> setNode ( $node )
-> setPermissions ( 31 );
2016-01-25 15:09:50 +03:00
$this -> defaultProvider -> expects ( $this -> once ())
-> method ( 'update' )
-> with ( $share )
-> willReturn ( $share );
$hookListner = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_set_expiration_date' , $hookListner , 'post' );
$hookListner -> expects ( $this -> never ()) -> method ( 'post' );
2016-02-04 11:53:47 +03:00
$hookListner2 = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_update_permissions' , $hookListner2 , 'post' );
$hookListner2 -> expects ( $this -> never ()) -> method ( 'post' );
2016-01-25 15:09:50 +03:00
$manager -> updateShare ( $share );
}
public function testUpdateShareLink () {
$manager = $this -> createManagerMock ()
-> setMethods ([
'canShare' ,
'getShareById' ,
'generalCreateChecks' ,
'linkCreateChecks' ,
'pathCreateChecks' ,
'verifyPassword' ,
2016-01-26 16:29:30 +03:00
'validateExpirationDate' ,
2016-01-25 15:09:50 +03:00
])
-> getMock ();
2016-02-04 14:51:23 +03:00
$originalShare = $this -> manager -> newShare ();
2016-02-04 11:53:47 +03:00
$originalShare -> setShareType ( \OCP\Share :: SHARE_TYPE_LINK )
-> setPermissions ( 15 );
2016-01-25 15:09:50 +03:00
$tomorrow = new \DateTime ();
$tomorrow -> setTime ( 0 , 0 , 0 );
$tomorrow -> add ( new \DateInterval ( 'P1D' ));
2016-09-12 22:38:56 +03:00
$file = $this -> createMock ( File :: class );
2016-01-25 15:09:50 +03:00
$file -> method ( 'getId' ) -> willReturn ( 100 );
2016-01-30 01:04:42 +03:00
$share = $this -> manager -> newShare ();
2016-01-25 15:09:50 +03:00
$share -> setProviderId ( 'foo' )
-> setId ( '42' )
-> setShareType ( \OCP\Share :: SHARE_TYPE_LINK )
2017-04-23 20:10:00 +03:00
-> setToken ( 'token' )
2016-02-02 23:02:09 +03:00
-> setSharedBy ( 'owner' )
-> setShareOwner ( 'owner' )
2016-01-25 15:09:50 +03:00
-> setPassword ( 'password' )
-> setExpirationDate ( $tomorrow )
2016-02-04 11:53:47 +03:00
-> setNode ( $file )
-> setPermissions ( 15 );
2016-01-25 15:09:50 +03:00
2016-01-30 01:04:42 +03:00
$manager -> expects ( $this -> once ()) -> method ( 'canShare' ) -> willReturn ( true );
$manager -> expects ( $this -> once ()) -> method ( 'getShareById' ) -> with ( 'foo:42' ) -> willReturn ( $originalShare );
$manager -> expects ( $this -> once ()) -> method ( 'validateExpirationDate' ) -> with ( $share );
2017-04-23 20:04:06 +03:00
$manager -> expects ( $this -> once ()) -> method ( 'verifyPassword' ) -> with ( 'password' );
$this -> hasher -> expects ( $this -> once ())
-> method ( 'hash' )
-> with ( 'password' )
-> willReturn ( 'hashed' );
2016-01-30 01:04:42 +03:00
2016-01-25 15:09:50 +03:00
$this -> defaultProvider -> expects ( $this -> once ())
-> method ( 'update' )
-> with ( $share )
-> willReturn ( $share );
$hookListner = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_set_expiration_date' , $hookListner , 'post' );
$hookListner -> expects ( $this -> once ()) -> method ( 'post' ) -> with ([
'itemType' => 'file' ,
'itemSource' => 100 ,
'date' => $tomorrow ,
'uidOwner' => 'owner' ,
]);
2016-02-04 11:53:47 +03:00
$hookListner2 = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
2017-04-23 20:10:00 +03:00
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_update_password' , $hookListner2 , 'post' );
$hookListner2 -> expects ( $this -> once ()) -> method ( 'post' ) -> with ([
'itemType' => 'file' ,
'itemSource' => 100 ,
'uidOwner' => 'owner' ,
'token' => 'token' ,
'disabled' => false ,
]);
$hookListner3 = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_update_permissions' , $hookListner3 , 'post' );
$hookListner3 -> expects ( $this -> never ()) -> method ( 'post' );
2016-02-04 11:53:47 +03:00
2016-01-25 15:09:50 +03:00
$manager -> updateShare ( $share );
}
2016-01-29 12:27:39 +03:00
2020-05-28 21:29:28 +03:00
public function testUpdateShareLinkEnableSendPasswordByTalkWithNoPassword () {
$this -> expectException ( \InvalidArgumentException :: class );
$this -> expectExceptionMessage ( 'Can’ t enable sending the password by Talk with an empty password' );
$manager = $this -> createManagerMock ()
-> setMethods ([
'canShare' ,
'getShareById' ,
'generalCreateChecks' ,
'linkCreateChecks' ,
'pathCreateChecks' ,
'verifyPassword' ,
'validateExpirationDate' ,
])
-> getMock ();
$originalShare = $this -> manager -> newShare ();
$originalShare -> setShareType ( \OCP\Share :: SHARE_TYPE_LINK )
-> setPermissions ( 15 );
$tomorrow = new \DateTime ();
$tomorrow -> setTime ( 0 , 0 , 0 );
$tomorrow -> add ( new \DateInterval ( 'P1D' ));
$file = $this -> createMock ( File :: class );
$file -> method ( 'getId' ) -> willReturn ( 100 );
$share = $this -> manager -> newShare ();
$share -> setProviderId ( 'foo' )
-> setId ( '42' )
-> setShareType ( \OCP\Share :: SHARE_TYPE_LINK )
-> setToken ( 'token' )
-> setSharedBy ( 'owner' )
-> setShareOwner ( 'owner' )
-> setPassword ( null )
-> setSendPasswordByTalk ( true )
-> setExpirationDate ( $tomorrow )
-> setNode ( $file )
-> setPermissions ( 15 );
$manager -> expects ( $this -> once ()) -> method ( 'canShare' ) -> willReturn ( true );
$manager -> expects ( $this -> once ()) -> method ( 'getShareById' ) -> with ( 'foo:42' ) -> willReturn ( $originalShare );
$manager -> expects ( $this -> once ()) -> method ( 'generalCreateChecks' ) -> with ( $share );
$manager -> expects ( $this -> once ()) -> method ( 'linkCreateChecks' ) -> with ( $share );
$manager -> expects ( $this -> never ()) -> method ( 'verifyPassword' );
$manager -> expects ( $this -> never ()) -> method ( 'pathCreateChecks' );
$manager -> expects ( $this -> never ()) -> method ( 'validateExpirationDate' );
$this -> hasher -> expects ( $this -> never ())
-> method ( 'hash' );
$this -> defaultProvider -> expects ( $this -> never ())
-> method ( 'update' );
$hookListner = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_set_expiration_date' , $hookListner , 'post' );
$hookListner -> expects ( $this -> never ()) -> method ( 'post' );
$hookListner2 = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_update_password' , $hookListner2 , 'post' );
$hookListner2 -> expects ( $this -> never ()) -> method ( 'post' );
$hookListner3 = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_update_permissions' , $hookListner3 , 'post' );
$hookListner3 -> expects ( $this -> never ()) -> method ( 'post' );
$manager -> updateShare ( $share );
}
2017-04-23 20:11:06 +03:00
public function testUpdateShareMail () {
$manager = $this -> createManagerMock ()
-> setMethods ([
'canShare' ,
'getShareById' ,
'generalCreateChecks' ,
'verifyPassword' ,
'pathCreateChecks' ,
'linkCreateChecks' ,
'validateExpirationDate' ,
])
-> getMock ();
$originalShare = $this -> manager -> newShare ();
$originalShare -> setShareType ( \OCP\Share :: SHARE_TYPE_EMAIL )
-> setPermissions ( \OCP\Constants :: PERMISSION_ALL );
$tomorrow = new \DateTime ();
$tomorrow -> setTime ( 0 , 0 , 0 );
$tomorrow -> add ( new \DateInterval ( 'P1D' ));
$file = $this -> createMock ( File :: class );
$file -> method ( 'getId' ) -> willReturn ( 100 );
$share = $this -> manager -> newShare ();
$share -> setProviderId ( 'foo' )
-> setId ( '42' )
-> setShareType ( \OCP\Share :: SHARE_TYPE_EMAIL )
-> setToken ( 'token' )
-> setSharedBy ( 'owner' )
-> setShareOwner ( 'owner' )
-> setPassword ( 'password' )
-> setExpirationDate ( $tomorrow )
-> setNode ( $file )
-> setPermissions ( \OCP\Constants :: PERMISSION_ALL );
$manager -> expects ( $this -> once ()) -> method ( 'canShare' ) -> willReturn ( true );
$manager -> expects ( $this -> once ()) -> method ( 'getShareById' ) -> with ( 'foo:42' ) -> willReturn ( $originalShare );
$manager -> expects ( $this -> once ()) -> method ( 'generalCreateChecks' ) -> with ( $share );
$manager -> expects ( $this -> once ()) -> method ( 'verifyPassword' ) -> with ( 'password' );
$manager -> expects ( $this -> once ()) -> method ( 'pathCreateChecks' ) -> with ( $file );
$manager -> expects ( $this -> never ()) -> method ( 'linkCreateChecks' );
$manager -> expects ( $this -> never ()) -> method ( 'validateExpirationDate' );
$this -> hasher -> expects ( $this -> once ())
-> method ( 'hash' )
-> with ( 'password' )
-> willReturn ( 'hashed' );
$this -> defaultProvider -> expects ( $this -> once ())
-> method ( 'update' )
-> with ( $share , 'password' )
-> willReturn ( $share );
$hookListner = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_set_expiration_date' , $hookListner , 'post' );
$hookListner -> expects ( $this -> never ()) -> method ( 'post' );
$hookListner2 = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_update_password' , $hookListner2 , 'post' );
$hookListner2 -> expects ( $this -> once ()) -> method ( 'post' ) -> with ([
'itemType' => 'file' ,
'itemSource' => 100 ,
'uidOwner' => 'owner' ,
'token' => 'token' ,
'disabled' => false ,
]);
$hookListner3 = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_update_permissions' , $hookListner3 , 'post' );
$hookListner3 -> expects ( $this -> never ()) -> method ( 'post' );
$manager -> updateShare ( $share );
}
2018-07-10 13:36:28 +03:00
public function testUpdateShareMailEnableSendPasswordByTalk () {
$manager = $this -> createManagerMock ()
-> setMethods ([
'canShare' ,
'getShareById' ,
'generalCreateChecks' ,
'verifyPassword' ,
'pathCreateChecks' ,
'linkCreateChecks' ,
'validateExpirationDate' ,
])
-> getMock ();
$originalShare = $this -> manager -> newShare ();
$originalShare -> setShareType ( \OCP\Share :: SHARE_TYPE_EMAIL )
-> setPermissions ( \OCP\Constants :: PERMISSION_ALL )
-> setPassword ( null )
-> setSendPasswordByTalk ( false );
$tomorrow = new \DateTime ();
$tomorrow -> setTime ( 0 , 0 , 0 );
$tomorrow -> add ( new \DateInterval ( 'P1D' ));
$file = $this -> createMock ( File :: class );
$file -> method ( 'getId' ) -> willReturn ( 100 );
$share = $this -> manager -> newShare ();
$share -> setProviderId ( 'foo' )
-> setId ( '42' )
-> setShareType ( \OCP\Share :: SHARE_TYPE_EMAIL )
-> setToken ( 'token' )
-> setSharedBy ( 'owner' )
-> setShareOwner ( 'owner' )
-> setPassword ( 'password' )
-> setSendPasswordByTalk ( true )
-> setExpirationDate ( $tomorrow )
-> setNode ( $file )
-> setPermissions ( \OCP\Constants :: PERMISSION_ALL );
$manager -> expects ( $this -> once ()) -> method ( 'canShare' ) -> willReturn ( true );
$manager -> expects ( $this -> once ()) -> method ( 'getShareById' ) -> with ( 'foo:42' ) -> willReturn ( $originalShare );
$manager -> expects ( $this -> once ()) -> method ( 'generalCreateChecks' ) -> with ( $share );
$manager -> expects ( $this -> once ()) -> method ( 'verifyPassword' ) -> with ( 'password' );
$manager -> expects ( $this -> once ()) -> method ( 'pathCreateChecks' ) -> with ( $file );
$manager -> expects ( $this -> never ()) -> method ( 'linkCreateChecks' );
$manager -> expects ( $this -> never ()) -> method ( 'validateExpirationDate' );
$this -> hasher -> expects ( $this -> once ())
-> method ( 'hash' )
-> with ( 'password' )
-> willReturn ( 'hashed' );
$this -> defaultProvider -> expects ( $this -> once ())
-> method ( 'update' )
-> with ( $share , 'password' )
-> willReturn ( $share );
$hookListner = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_set_expiration_date' , $hookListner , 'post' );
$hookListner -> expects ( $this -> never ()) -> method ( 'post' );
$hookListner2 = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_update_password' , $hookListner2 , 'post' );
$hookListner2 -> expects ( $this -> once ()) -> method ( 'post' ) -> with ([
'itemType' => 'file' ,
'itemSource' => 100 ,
'uidOwner' => 'owner' ,
'token' => 'token' ,
'disabled' => false ,
]);
$hookListner3 = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_update_permissions' , $hookListner3 , 'post' );
$hookListner3 -> expects ( $this -> never ()) -> method ( 'post' );
$manager -> updateShare ( $share );
}
2019-12-12 23:38:52 +03:00
2018-07-10 13:36:28 +03:00
public function testUpdateShareMailEnableSendPasswordByTalkWithNoPassword () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \InvalidArgumentException :: class );
$this -> expectExceptionMessage ( 'Can’ t enable sending the password by Talk without setting a new password' );
2018-07-10 13:36:28 +03:00
$manager = $this -> createManagerMock ()
-> setMethods ([
'canShare' ,
'getShareById' ,
'generalCreateChecks' ,
'verifyPassword' ,
'pathCreateChecks' ,
'linkCreateChecks' ,
'validateExpirationDate' ,
])
-> getMock ();
$originalShare = $this -> manager -> newShare ();
$originalShare -> setShareType ( \OCP\Share :: SHARE_TYPE_EMAIL )
-> setPermissions ( \OCP\Constants :: PERMISSION_ALL )
-> setPassword ( null )
-> setSendPasswordByTalk ( false );
$tomorrow = new \DateTime ();
$tomorrow -> setTime ( 0 , 0 , 0 );
$tomorrow -> add ( new \DateInterval ( 'P1D' ));
$file = $this -> createMock ( File :: class );
$file -> method ( 'getId' ) -> willReturn ( 100 );
$share = $this -> manager -> newShare ();
$share -> setProviderId ( 'foo' )
-> setId ( '42' )
-> setShareType ( \OCP\Share :: SHARE_TYPE_EMAIL )
-> setToken ( 'token' )
-> setSharedBy ( 'owner' )
-> setShareOwner ( 'owner' )
-> setPassword ( null )
-> setSendPasswordByTalk ( true )
-> setExpirationDate ( $tomorrow )
-> setNode ( $file )
-> setPermissions ( \OCP\Constants :: PERMISSION_ALL );
$manager -> expects ( $this -> once ()) -> method ( 'canShare' ) -> willReturn ( true );
$manager -> expects ( $this -> once ()) -> method ( 'getShareById' ) -> with ( 'foo:42' ) -> willReturn ( $originalShare );
$manager -> expects ( $this -> once ()) -> method ( 'generalCreateChecks' ) -> with ( $share );
$manager -> expects ( $this -> never ()) -> method ( 'verifyPassword' );
$manager -> expects ( $this -> never ()) -> method ( 'pathCreateChecks' );
$manager -> expects ( $this -> never ()) -> method ( 'linkCreateChecks' );
$manager -> expects ( $this -> never ()) -> method ( 'validateExpirationDate' );
$this -> hasher -> expects ( $this -> never ())
-> method ( 'hash' );
$this -> defaultProvider -> expects ( $this -> never ())
-> method ( 'update' );
$hookListner = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_set_expiration_date' , $hookListner , 'post' );
$hookListner -> expects ( $this -> never ()) -> method ( 'post' );
$hookListner2 = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_update_password' , $hookListner2 , 'post' );
$hookListner2 -> expects ( $this -> never ()) -> method ( 'post' );
$hookListner3 = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_update_permissions' , $hookListner3 , 'post' );
$hookListner3 -> expects ( $this -> never ()) -> method ( 'post' );
$manager -> updateShare ( $share );
}
2019-12-12 23:38:52 +03:00
2018-07-10 13:36:28 +03:00
public function testUpdateShareMailEnableSendPasswordByTalkRemovingPassword () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \InvalidArgumentException :: class );
$this -> expectExceptionMessage ( 'Can’ t enable sending the password by Talk without setting a new password' );
2018-07-10 13:36:28 +03:00
$manager = $this -> createManagerMock ()
-> setMethods ([
'canShare' ,
'getShareById' ,
'generalCreateChecks' ,
'verifyPassword' ,
'pathCreateChecks' ,
'linkCreateChecks' ,
'validateExpirationDate' ,
])
-> getMock ();
$originalShare = $this -> manager -> newShare ();
$originalShare -> setShareType ( \OCP\Share :: SHARE_TYPE_EMAIL )
-> setPermissions ( \OCP\Constants :: PERMISSION_ALL )
-> setPassword ( 'password' )
-> setSendPasswordByTalk ( false );
$tomorrow = new \DateTime ();
$tomorrow -> setTime ( 0 , 0 , 0 );
$tomorrow -> add ( new \DateInterval ( 'P1D' ));
$file = $this -> createMock ( File :: class );
$file -> method ( 'getId' ) -> willReturn ( 100 );
$share = $this -> manager -> newShare ();
$share -> setProviderId ( 'foo' )
-> setId ( '42' )
-> setShareType ( \OCP\Share :: SHARE_TYPE_EMAIL )
-> setToken ( 'token' )
-> setSharedBy ( 'owner' )
-> setShareOwner ( 'owner' )
-> setPassword ( null )
-> setSendPasswordByTalk ( true )
-> setExpirationDate ( $tomorrow )
-> setNode ( $file )
-> setPermissions ( \OCP\Constants :: PERMISSION_ALL );
$manager -> expects ( $this -> once ()) -> method ( 'canShare' ) -> willReturn ( true );
$manager -> expects ( $this -> once ()) -> method ( 'getShareById' ) -> with ( 'foo:42' ) -> willReturn ( $originalShare );
$manager -> expects ( $this -> once ()) -> method ( 'generalCreateChecks' ) -> with ( $share );
$manager -> expects ( $this -> never ()) -> method ( 'verifyPassword' );
$manager -> expects ( $this -> never ()) -> method ( 'pathCreateChecks' );
$manager -> expects ( $this -> never ()) -> method ( 'linkCreateChecks' );
$manager -> expects ( $this -> never ()) -> method ( 'validateExpirationDate' );
$this -> hasher -> expects ( $this -> never ())
-> method ( 'hash' );
$this -> defaultProvider -> expects ( $this -> never ())
-> method ( 'update' );
$hookListner = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_set_expiration_date' , $hookListner , 'post' );
$hookListner -> expects ( $this -> never ()) -> method ( 'post' );
$hookListner2 = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_update_password' , $hookListner2 , 'post' );
$hookListner2 -> expects ( $this -> never ()) -> method ( 'post' );
$hookListner3 = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_update_permissions' , $hookListner3 , 'post' );
$hookListner3 -> expects ( $this -> never ()) -> method ( 'post' );
$manager -> updateShare ( $share );
}
2019-12-12 23:38:52 +03:00
2018-07-10 13:36:28 +03:00
public function testUpdateShareMailEnableSendPasswordByTalkRemovingPasswordWithEmptyString () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \InvalidArgumentException :: class );
$this -> expectExceptionMessage ( 'Can’ t enable sending the password by Talk without setting a new password' );
2018-07-10 13:36:28 +03:00
$manager = $this -> createManagerMock ()
-> setMethods ([
'canShare' ,
'getShareById' ,
'generalCreateChecks' ,
'verifyPassword' ,
'pathCreateChecks' ,
'linkCreateChecks' ,
'validateExpirationDate' ,
])
-> getMock ();
$originalShare = $this -> manager -> newShare ();
$originalShare -> setShareType ( \OCP\Share :: SHARE_TYPE_EMAIL )
-> setPermissions ( \OCP\Constants :: PERMISSION_ALL )
-> setPassword ( 'password' )
-> setSendPasswordByTalk ( false );
$tomorrow = new \DateTime ();
$tomorrow -> setTime ( 0 , 0 , 0 );
$tomorrow -> add ( new \DateInterval ( 'P1D' ));
$file = $this -> createMock ( File :: class );
$file -> method ( 'getId' ) -> willReturn ( 100 );
$share = $this -> manager -> newShare ();
$share -> setProviderId ( 'foo' )
-> setId ( '42' )
-> setShareType ( \OCP\Share :: SHARE_TYPE_EMAIL )
-> setToken ( 'token' )
-> setSharedBy ( 'owner' )
-> setShareOwner ( 'owner' )
-> setPassword ( '' )
-> setSendPasswordByTalk ( true )
-> setExpirationDate ( $tomorrow )
-> setNode ( $file )
-> setPermissions ( \OCP\Constants :: PERMISSION_ALL );
$manager -> expects ( $this -> once ()) -> method ( 'canShare' ) -> willReturn ( true );
$manager -> expects ( $this -> once ()) -> method ( 'getShareById' ) -> with ( 'foo:42' ) -> willReturn ( $originalShare );
$manager -> expects ( $this -> once ()) -> method ( 'generalCreateChecks' ) -> with ( $share );
$manager -> expects ( $this -> never ()) -> method ( 'verifyPassword' );
$manager -> expects ( $this -> never ()) -> method ( 'pathCreateChecks' );
$manager -> expects ( $this -> never ()) -> method ( 'linkCreateChecks' );
$manager -> expects ( $this -> never ()) -> method ( 'validateExpirationDate' );
$this -> hasher -> expects ( $this -> never ())
-> method ( 'hash' );
$this -> defaultProvider -> expects ( $this -> never ())
-> method ( 'update' );
$hookListner = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_set_expiration_date' , $hookListner , 'post' );
$hookListner -> expects ( $this -> never ()) -> method ( 'post' );
$hookListner2 = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_update_password' , $hookListner2 , 'post' );
$hookListner2 -> expects ( $this -> never ()) -> method ( 'post' );
$hookListner3 = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_update_permissions' , $hookListner3 , 'post' );
$hookListner3 -> expects ( $this -> never ()) -> method ( 'post' );
$manager -> updateShare ( $share );
}
2019-12-12 23:38:52 +03:00
2018-07-10 13:36:28 +03:00
public function testUpdateShareMailEnableSendPasswordByTalkWithPreviousPassword () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \InvalidArgumentException :: class );
$this -> expectExceptionMessage ( 'Can’ t enable sending the password by Talk without setting a new password' );
2018-07-10 13:36:28 +03:00
$manager = $this -> createManagerMock ()
-> setMethods ([
'canShare' ,
'getShareById' ,
'generalCreateChecks' ,
'verifyPassword' ,
'pathCreateChecks' ,
'linkCreateChecks' ,
'validateExpirationDate' ,
])
-> getMock ();
$originalShare = $this -> manager -> newShare ();
$originalShare -> setShareType ( \OCP\Share :: SHARE_TYPE_EMAIL )
-> setPermissions ( \OCP\Constants :: PERMISSION_ALL )
-> setPassword ( 'password' )
-> setSendPasswordByTalk ( false );
$tomorrow = new \DateTime ();
$tomorrow -> setTime ( 0 , 0 , 0 );
$tomorrow -> add ( new \DateInterval ( 'P1D' ));
$file = $this -> createMock ( File :: class );
$file -> method ( 'getId' ) -> willReturn ( 100 );
$share = $this -> manager -> newShare ();
$share -> setProviderId ( 'foo' )
-> setId ( '42' )
-> setShareType ( \OCP\Share :: SHARE_TYPE_EMAIL )
-> setToken ( 'token' )
-> setSharedBy ( 'owner' )
-> setShareOwner ( 'owner' )
-> setPassword ( 'password' )
-> setSendPasswordByTalk ( true )
-> setExpirationDate ( $tomorrow )
-> setNode ( $file )
-> setPermissions ( \OCP\Constants :: PERMISSION_ALL );
$manager -> expects ( $this -> once ()) -> method ( 'canShare' ) -> willReturn ( true );
$manager -> expects ( $this -> once ()) -> method ( 'getShareById' ) -> with ( 'foo:42' ) -> willReturn ( $originalShare );
$manager -> expects ( $this -> once ()) -> method ( 'generalCreateChecks' ) -> with ( $share );
$manager -> expects ( $this -> never ()) -> method ( 'verifyPassword' );
$manager -> expects ( $this -> never ()) -> method ( 'pathCreateChecks' );
$manager -> expects ( $this -> never ()) -> method ( 'linkCreateChecks' );
$manager -> expects ( $this -> never ()) -> method ( 'validateExpirationDate' );
$this -> hasher -> expects ( $this -> never ())
-> method ( 'hash' );
$this -> defaultProvider -> expects ( $this -> never ())
-> method ( 'update' );
$hookListner = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_set_expiration_date' , $hookListner , 'post' );
$hookListner -> expects ( $this -> never ()) -> method ( 'post' );
$hookListner2 = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_update_password' , $hookListner2 , 'post' );
$hookListner2 -> expects ( $this -> never ()) -> method ( 'post' );
$hookListner3 = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_update_permissions' , $hookListner3 , 'post' );
$hookListner3 -> expects ( $this -> never ()) -> method ( 'post' );
$manager -> updateShare ( $share );
}
public function testUpdateShareMailDisableSendPasswordByTalkWithPreviousPassword () {
$manager = $this -> createManagerMock ()
-> setMethods ([
'canShare' ,
'getShareById' ,
'generalCreateChecks' ,
'verifyPassword' ,
'pathCreateChecks' ,
'linkCreateChecks' ,
'validateExpirationDate' ,
])
-> getMock ();
$originalShare = $this -> manager -> newShare ();
$originalShare -> setShareType ( \OCP\Share :: SHARE_TYPE_EMAIL )
-> setPermissions ( \OCP\Constants :: PERMISSION_ALL )
-> setPassword ( 'password' )
-> setSendPasswordByTalk ( true );
$tomorrow = new \DateTime ();
$tomorrow -> setTime ( 0 , 0 , 0 );
$tomorrow -> add ( new \DateInterval ( 'P1D' ));
$file = $this -> createMock ( File :: class );
$file -> method ( 'getId' ) -> willReturn ( 100 );
$share = $this -> manager -> newShare ();
$share -> setProviderId ( 'foo' )
-> setId ( '42' )
-> setShareType ( \OCP\Share :: SHARE_TYPE_EMAIL )
-> setToken ( 'token' )
-> setSharedBy ( 'owner' )
-> setShareOwner ( 'owner' )
-> setPassword ( 'password' )
-> setSendPasswordByTalk ( false )
-> setExpirationDate ( $tomorrow )
-> setNode ( $file )
-> setPermissions ( \OCP\Constants :: PERMISSION_ALL );
$manager -> expects ( $this -> once ()) -> method ( 'canShare' ) -> willReturn ( true );
$manager -> expects ( $this -> once ()) -> method ( 'getShareById' ) -> with ( 'foo:42' ) -> willReturn ( $originalShare );
$manager -> expects ( $this -> once ()) -> method ( 'generalCreateChecks' ) -> with ( $share );
$manager -> expects ( $this -> once ()) -> method ( 'pathCreateChecks' ) -> with ( $file );
$manager -> expects ( $this -> never ()) -> method ( 'verifyPassword' );
$manager -> expects ( $this -> never ()) -> method ( 'linkCreateChecks' );
$manager -> expects ( $this -> never ()) -> method ( 'validateExpirationDate' );
$this -> hasher -> expects ( $this -> never ())
-> method ( 'hash' );
$this -> defaultProvider -> expects ( $this -> once ())
-> method ( 'update' )
-> with ( $share , 'password' )
-> willReturn ( $share );
$hookListner = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_set_expiration_date' , $hookListner , 'post' );
$hookListner -> expects ( $this -> never ()) -> method ( 'post' );
$hookListner2 = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_update_password' , $hookListner2 , 'post' );
$hookListner2 -> expects ( $this -> never ()) -> method ( 'post' );
$hookListner3 = $this -> getMockBuilder ( 'Dummy' ) -> setMethods ([ 'post' ]) -> getMock ();
\OCP\Util :: connectHook ( 'OCP\Share' , 'post_update_permissions' , $hookListner3 , 'post' );
$hookListner3 -> expects ( $this -> never ()) -> method ( 'post' );
$manager -> updateShare ( $share );
}
2019-12-12 23:38:52 +03:00
2016-01-29 12:27:39 +03:00
public function testMoveShareLink () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \InvalidArgumentException :: class );
$this -> expectExceptionMessage ( 'Can’ t change target of link share' );
2016-01-29 12:27:39 +03:00
$share = $this -> manager -> newShare ();
$share -> setShareType ( \OCP\Share :: SHARE_TYPE_LINK );
2016-09-02 12:24:43 +03:00
$recipient = $this -> createMock ( IUser :: class );
2016-01-29 12:27:39 +03:00
$this -> manager -> moveShare ( $share , $recipient );
}
2019-12-12 23:38:52 +03:00
2016-01-29 12:27:39 +03:00
public function testMoveShareUserNotRecipient () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \InvalidArgumentException :: class );
$this -> expectExceptionMessage ( 'Invalid recipient' );
2016-01-29 12:27:39 +03:00
$share = $this -> manager -> newShare ();
$share -> setShareType ( \OCP\Share :: SHARE_TYPE_USER );
2016-02-02 23:02:09 +03:00
$share -> setSharedWith ( 'sharedWith' );
2016-01-29 12:27:39 +03:00
2016-02-02 23:02:09 +03:00
$this -> manager -> moveShare ( $share , 'recipient' );
2016-01-29 12:27:39 +03:00
}
public function testMoveShareUser () {
$share = $this -> manager -> newShare ();
2016-04-15 10:02:17 +03:00
$share -> setShareType ( \OCP\Share :: SHARE_TYPE_USER )
-> setId ( '42' )
-> setProviderId ( 'foo' );
2016-01-29 12:27:39 +03:00
2016-02-02 23:02:09 +03:00
$share -> setSharedWith ( 'recipient' );
2016-01-29 12:27:39 +03:00
2020-03-26 00:21:27 +03:00
$this -> defaultProvider -> method ( 'move' ) -> with ( $share , 'recipient' ) -> willReturnArgument ( 0 );
2016-01-29 12:27:39 +03:00
2016-02-02 23:02:09 +03:00
$this -> manager -> moveShare ( $share , 'recipient' );
2018-01-25 13:23:12 +03:00
$this -> addToAssertionCount ( 1 );
2016-01-29 12:27:39 +03:00
}
2019-12-12 23:38:52 +03:00
2016-01-29 12:27:39 +03:00
public function testMoveShareGroupNotRecipient () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \InvalidArgumentException :: class );
$this -> expectExceptionMessage ( 'Invalid recipient' );
2016-01-29 12:27:39 +03:00
$share = $this -> manager -> newShare ();
$share -> setShareType ( \OCP\Share :: SHARE_TYPE_GROUP );
2016-09-02 12:24:43 +03:00
$sharedWith = $this -> createMock ( IGroup :: class );
2016-02-02 23:02:09 +03:00
$share -> setSharedWith ( 'shareWith' );
2016-01-29 12:27:39 +03:00
2016-09-02 12:24:43 +03:00
$recipient = $this -> createMock ( IUser :: class );
2016-01-29 12:27:39 +03:00
$sharedWith -> method ( 'inGroup' ) -> with ( $recipient ) -> willReturn ( false );
2016-02-02 23:02:09 +03:00
$this -> groupManager -> method ( 'get' ) -> with ( 'shareWith' ) -> willReturn ( $sharedWith );
$this -> userManager -> method ( 'get' ) -> with ( 'recipient' ) -> willReturn ( $recipient );
$this -> manager -> moveShare ( $share , 'recipient' );
2016-01-29 12:27:39 +03:00
}
2019-12-12 23:38:52 +03:00
2017-01-19 17:02:46 +03:00
public function testMoveShareGroupNull () {
2019-11-27 17:27:18 +03:00
$this -> expectException ( \InvalidArgumentException :: class );
$this -> expectExceptionMessage ( 'Group "shareWith" does not exist' );
2017-01-19 17:02:46 +03:00
$share = $this -> manager -> newShare ();
$share -> setShareType ( \OCP\Share :: SHARE_TYPE_GROUP );
$share -> setSharedWith ( 'shareWith' );
2017-04-10 17:53:58 +03:00
$recipient = $this -> createMock ( IUser :: class );
2017-01-19 17:02:46 +03:00
$this -> groupManager -> method ( 'get' ) -> with ( 'shareWith' ) -> willReturn ( null );
$this -> userManager -> method ( 'get' ) -> with ( 'recipient' ) -> willReturn ( $recipient );
$this -> manager -> moveShare ( $share , 'recipient' );
}
2016-01-29 12:27:39 +03:00
public function testMoveShareGroup () {
$share = $this -> manager -> newShare ();
2016-04-15 10:02:17 +03:00
$share -> setShareType ( \OCP\Share :: SHARE_TYPE_GROUP )
-> setId ( '42' )
-> setProviderId ( 'foo' );
2016-01-29 12:27:39 +03:00
2016-09-02 12:24:43 +03:00
$group = $this -> createMock ( IGroup :: class );
2016-02-02 23:02:09 +03:00
$share -> setSharedWith ( 'group' );
2016-01-29 12:27:39 +03:00
2016-09-02 12:24:43 +03:00
$recipient = $this -> createMock ( IUser :: class );
2016-02-02 23:02:09 +03:00
$group -> method ( 'inGroup' ) -> with ( $recipient ) -> willReturn ( true );
2016-01-29 12:27:39 +03:00
2016-02-02 23:02:09 +03:00
$this -> groupManager -> method ( 'get' ) -> with ( 'group' ) -> willReturn ( $group );
$this -> userManager -> method ( 'get' ) -> with ( 'recipient' ) -> willReturn ( $recipient );
2016-01-29 12:27:39 +03:00
2020-03-26 00:21:27 +03:00
$this -> defaultProvider -> method ( 'move' ) -> with ( $share , 'recipient' ) -> willReturnArgument ( 0 );
2016-02-02 23:02:09 +03:00
$this -> manager -> moveShare ( $share , 'recipient' );
2018-01-25 13:23:12 +03:00
$this -> addToAssertionCount ( 1 );
2016-01-29 12:27:39 +03:00
}
2016-11-01 14:35:50 +03:00
2016-10-24 18:03:36 +03:00
/**
* @ dataProvider dataTestShareProviderExists
*/
public function testShareProviderExists ( $shareType , $expected ) {
$factory = $this -> getMockBuilder ( 'OCP\Share\IProviderFactory' ) -> getMock ();
$factory -> expects ( $this -> any ()) -> method ( 'getProviderForType' )
-> willReturnCallback ( function ( $id ) {
if ( $id === \OCP\Share :: SHARE_TYPE_USER ) {
return true ;
}
throw new Exception\ProviderException ();
});
$manager = new Manager (
$this -> logger ,
$this -> config ,
$this -> secureRandom ,
$this -> hasher ,
$this -> mountManager ,
$this -> groupManager ,
$this -> l ,
2017-09-08 11:34:19 +03:00
$this -> l10nFactory ,
2016-10-24 18:03:36 +03:00
$factory ,
$this -> userManager ,
$this -> rootFolder ,
2017-07-27 00:53:07 +03:00
$this -> eventDispatcher ,
$this -> mailer ,
$this -> urlGenerator ,
2019-12-12 23:38:52 +03:00
$this -> defaults ,
$this -> dispatcher
2016-10-24 18:03:36 +03:00
);
$this -> assertSame ( $expected ,
$manager -> shareProviderExists ( $shareType )
);
}
public function dataTestShareProviderExists () {
return [
[ \OCP\Share :: SHARE_TYPE_USER , true ],
[ 42 , false ],
];
}
2016-11-01 14:35:50 +03:00
public function testGetSharesInFolder () {
$factory = new DummyFactory2 ( $this -> createMock ( IServerContainer :: class ));
$manager = new Manager (
$this -> logger ,
$this -> config ,
$this -> secureRandom ,
$this -> hasher ,
$this -> mountManager ,
$this -> groupManager ,
$this -> l ,
2017-09-08 11:34:19 +03:00
$this -> l10nFactory ,
2016-11-01 14:35:50 +03:00
$factory ,
$this -> userManager ,
$this -> rootFolder ,
2017-07-27 00:53:07 +03:00
$this -> eventDispatcher ,
$this -> mailer ,
$this -> urlGenerator ,
2019-12-12 23:38:52 +03:00
$this -> defaults ,
$this -> dispatcher
2016-11-01 14:35:50 +03:00
);
$factory -> setProvider ( $this -> defaultProvider );
$extraProvider = $this -> createMock ( IShareProvider :: class );
$factory -> setSecondProvider ( $extraProvider );
$share1 = $this -> createMock ( IShare :: class );
$share2 = $this -> createMock ( IShare :: class );
$share3 = $this -> createMock ( IShare :: class );
$share4 = $this -> createMock ( IShare :: class );
$folder = $this -> createMock ( Folder :: class );
$this -> defaultProvider -> method ( 'getSharesInFolder' )
-> with (
$this -> equalTo ( 'user' ),
$this -> equalTo ( $folder ),
$this -> equalTo ( false )
) -> willReturn ([
1 => [ $share1 ],
2 => [ $share2 ],
]);
$extraProvider -> method ( 'getSharesInFolder' )
-> with (
$this -> equalTo ( 'user' ),
$this -> equalTo ( $folder ),
$this -> equalTo ( false )
) -> willReturn ([
2 => [ $share3 ],
3 => [ $share4 ],
]);
$result = $manager -> getSharesInFolder ( 'user' , $folder , false );
$expects = [
1 => [ $share1 ],
2 => [ $share2 , $share3 ],
3 => [ $share4 ],
];
$this -> assertSame ( $expects , $result );
}
2016-09-09 13:53:17 +03:00
public function testGetAccessList () {
2016-12-22 23:44:21 +03:00
$factory = new DummyFactory2 ( $this -> createMock ( IServerContainer :: class ));
$manager = new Manager (
$this -> logger ,
$this -> config ,
$this -> secureRandom ,
$this -> hasher ,
$this -> mountManager ,
$this -> groupManager ,
$this -> l ,
2017-09-08 11:34:19 +03:00
$this -> l10nFactory ,
2016-12-22 23:44:21 +03:00
$factory ,
$this -> userManager ,
$this -> rootFolder ,
2017-07-27 00:53:07 +03:00
$this -> eventDispatcher ,
$this -> mailer ,
$this -> urlGenerator ,
2019-12-12 23:38:52 +03:00
$this -> defaults ,
$this -> dispatcher
2016-12-22 23:44:21 +03:00
);
$factory -> setProvider ( $this -> defaultProvider );
$extraProvider = $this -> createMock ( IShareProvider :: class );
$factory -> setSecondProvider ( $extraProvider );
2019-02-14 12:59:17 +03:00
$nodeOwner = $this -> createMock ( IUser :: class );
$nodeOwner -> expects ( $this -> once ())
2016-09-09 13:53:17 +03:00
-> method ( 'getUID' )
2019-02-14 12:59:17 +03:00
-> willReturn ( 'user1' );
2016-09-09 13:53:17 +03:00
$node = $this -> createMock ( Node :: class );
$node -> expects ( $this -> once ())
-> method ( 'getOwner' )
2019-02-14 12:59:17 +03:00
-> willReturn ( $nodeOwner );
2017-04-19 16:11:54 +03:00
$node -> method ( 'getId' )
2016-09-09 13:53:17 +03:00
-> willReturn ( 42 );
$userFolder = $this -> createMock ( Folder :: class );
$file = $this -> createMock ( File :: class );
$folder = $this -> createMock ( Folder :: class );
2019-02-14 12:59:17 +03:00
$owner = $this -> createMock ( IUser :: class );
$owner -> expects ( $this -> once ())
-> method ( 'getUID' )
-> willReturn ( 'owner' );
2017-11-28 19:16:47 +03:00
$file -> method ( 'getParent' )
-> willReturn ( $folder );
$file -> method ( 'getPath' )
-> willReturn ( '/owner/files/folder/file' );
2019-02-14 12:59:17 +03:00
$file -> method ( 'getOwner' )
-> willReturn ( $owner );
2017-11-28 19:16:47 +03:00
$file -> method ( 'getId' )
-> willReturn ( 23 );
$folder -> method ( 'getParent' )
-> willReturn ( $userFolder );
$folder -> method ( 'getPath' )
-> willReturn ( '/owner/files/folder' );
$userFolder -> method ( 'getById' )
-> with ( $this -> equalTo ( 42 ))
2019-02-14 12:59:17 +03:00
-> willReturn ([ 12 => $file ]);
2017-11-28 19:16:47 +03:00
$userFolder -> method ( 'getPath' )
2019-02-14 12:59:17 +03:00
-> willReturn ( '/user1/files' );
2017-11-28 19:16:47 +03:00
$this -> userManager -> method ( 'userExists' )
2019-02-14 12:59:17 +03:00
-> with ( $this -> equalTo ( 'user1' ))
2017-11-28 19:16:47 +03:00
-> willReturn ( true );
$this -> defaultProvider -> method ( 'getAccessList' )
-> with (
$this -> equalTo ([ $file , $folder ]),
false
)
-> willReturn ([
'users' => [
'user1' ,
'user2' ,
'user3' ,
'123456' ,
],
'public' => true ,
]);
$extraProvider -> method ( 'getAccessList' )
-> with (
$this -> equalTo ([ $file , $folder ]),
false
)
-> willReturn ([
'users' => [
'user3' ,
'user4' ,
'user5' ,
'234567' ,
],
'remote' => true ,
]);
$this -> rootFolder -> method ( 'getUserFolder' )
2019-02-14 12:59:17 +03:00
-> with ( $this -> equalTo ( 'user1' ))
2017-11-28 19:16:47 +03:00
-> willReturn ( $userFolder );
$expected = [
'users' => [ 'owner' , 'user1' , 'user2' , 'user3' , '123456' , 'user4' , 'user5' , '234567' ],
'remote' => true ,
'public' => true ,
];
$result = $manager -> getAccessList ( $node , true , false );
$this -> assertSame ( $expected [ 'public' ], $result [ 'public' ]);
$this -> assertSame ( $expected [ 'remote' ], $result [ 'remote' ]);
$this -> assertSame ( $expected [ 'users' ], $result [ 'users' ]);
}
public function testGetAccessListWithCurrentAccess () {
$factory = new DummyFactory2 ( $this -> createMock ( IServerContainer :: class ));
$manager = new Manager (
$this -> logger ,
$this -> config ,
$this -> secureRandom ,
$this -> hasher ,
$this -> mountManager ,
$this -> groupManager ,
$this -> l ,
$this -> l10nFactory ,
$factory ,
$this -> userManager ,
$this -> rootFolder ,
$this -> eventDispatcher ,
$this -> mailer ,
$this -> urlGenerator ,
2019-12-12 23:38:52 +03:00
$this -> defaults ,
$this -> dispatcher
2017-11-28 19:16:47 +03:00
);
$factory -> setProvider ( $this -> defaultProvider );
$extraProvider = $this -> createMock ( IShareProvider :: class );
$factory -> setSecondProvider ( $extraProvider );
2019-02-14 12:59:17 +03:00
$nodeOwner = $this -> createMock ( IUser :: class );
$nodeOwner -> expects ( $this -> once ())
2017-11-28 19:16:47 +03:00
-> method ( 'getUID' )
2019-02-14 12:59:17 +03:00
-> willReturn ( 'user1' );
2017-11-28 19:16:47 +03:00
$node = $this -> createMock ( Node :: class );
$node -> expects ( $this -> once ())
-> method ( 'getOwner' )
2019-02-14 12:59:17 +03:00
-> willReturn ( $nodeOwner );
2017-11-28 19:16:47 +03:00
$node -> method ( 'getId' )
-> willReturn ( 42 );
$userFolder = $this -> createMock ( Folder :: class );
$file = $this -> createMock ( File :: class );
2019-02-14 12:59:17 +03:00
$owner = $this -> createMock ( IUser :: class );
$owner -> expects ( $this -> once ())
-> method ( 'getUID' )
-> willReturn ( 'owner' );
2017-11-28 19:16:47 +03:00
$folder = $this -> createMock ( Folder :: class );
2016-09-09 13:53:17 +03:00
$file -> method ( 'getParent' )
-> willReturn ( $folder );
2016-10-27 16:16:53 +03:00
$file -> method ( 'getPath' )
-> willReturn ( '/owner/files/folder/file' );
2019-02-14 12:59:17 +03:00
$file -> method ( 'getOwner' )
-> willReturn ( $owner );
2017-04-10 17:53:58 +03:00
$file -> method ( 'getId' )
-> willReturn ( 23 );
2016-09-09 13:53:17 +03:00
$folder -> method ( 'getParent' )
-> willReturn ( $userFolder );
2016-10-27 16:16:53 +03:00
$folder -> method ( 'getPath' )
-> willReturn ( '/owner/files/folder' );
2016-09-09 13:53:17 +03:00
$userFolder -> method ( 'getById' )
-> with ( $this -> equalTo ( 42 ))
2019-02-14 12:59:17 +03:00
-> willReturn ([ 42 => $file ]);
2016-10-27 16:16:53 +03:00
$userFolder -> method ( 'getPath' )
2019-02-14 12:59:17 +03:00
-> willReturn ( '/user1/files' );
2016-09-09 13:53:17 +03:00
$this -> userManager -> method ( 'userExists' )
2019-02-14 12:59:17 +03:00
-> with ( $this -> equalTo ( 'user1' ))
2016-09-09 13:53:17 +03:00
-> willReturn ( true );
2016-12-22 23:44:21 +03:00
$this -> defaultProvider -> method ( 'getAccessList' )
-> with (
$this -> equalTo ([ $file , $folder ]),
true
)
-> willReturn ([
'users' => [
2017-04-10 17:53:58 +03:00
'user1' => [],
'user2' => [],
'user3' => [],
2017-11-28 19:16:47 +03:00
'123456' => [],
2016-12-22 23:44:21 +03:00
],
'public' => true ,
]);
$extraProvider -> method ( 'getAccessList' )
-> with (
$this -> equalTo ([ $file , $folder ]),
true
)
-> willReturn ([
'users' => [
2017-04-10 17:53:58 +03:00
'user3' => [],
'user4' => [],
'user5' => [],
2017-11-28 19:16:47 +03:00
'234567' => [],
2017-04-10 17:53:58 +03:00
],
'remote' => [
'remote1' ,
2016-12-22 23:44:21 +03:00
],
]);
2016-09-09 13:53:17 +03:00
$this -> rootFolder -> method ( 'getUserFolder' )
2019-02-14 12:59:17 +03:00
-> with ( $this -> equalTo ( 'user1' ))
2016-09-09 13:53:17 +03:00
-> willReturn ( $userFolder );
$expected = [
2017-04-10 17:53:58 +03:00
'users' => [
'owner' => [
'node_id' => 23 ,
'node_path' => '/folder/file'
]
2017-11-28 19:16:47 +03:00
, 'user1' => [], 'user2' => [], 'user3' => [], '123456' => [], 'user4' => [], 'user5' => [], '234567' => []],
2017-04-10 17:53:58 +03:00
'remote' => [
'remote1' ,
],
2016-09-09 13:53:17 +03:00
'public' => true ,
];
2016-12-22 23:44:21 +03:00
$result = $manager -> getAccessList ( $node , true , true );
$this -> assertSame ( $expected [ 'public' ], $result [ 'public' ]);
$this -> assertSame ( $expected [ 'remote' ], $result [ 'remote' ]);
2017-11-28 19:16:47 +03:00
$this -> assertSame ( $expected [ 'users' ], $result [ 'users' ]);
2016-09-09 13:53:17 +03:00
}
2019-10-30 16:27:17 +03:00
public function testGetAllShares () {
$factory = new DummyFactory2 ( $this -> createMock ( IServerContainer :: class ));
$manager = new Manager (
$this -> logger ,
$this -> config ,
$this -> secureRandom ,
$this -> hasher ,
$this -> mountManager ,
$this -> groupManager ,
$this -> l ,
$this -> l10nFactory ,
$factory ,
$this -> userManager ,
$this -> rootFolder ,
$this -> eventDispatcher ,
$this -> mailer ,
$this -> urlGenerator ,
2019-12-12 23:38:52 +03:00
$this -> defaults ,
$this -> dispatcher
2019-10-30 16:27:17 +03:00
);
$factory -> setProvider ( $this -> defaultProvider );
$extraProvider = $this -> createMock ( IShareProvider :: class );
$factory -> setSecondProvider ( $extraProvider );
$share1 = $this -> createMock ( IShare :: class );
$share2 = $this -> createMock ( IShare :: class );
$share3 = $this -> createMock ( IShare :: class );
$share4 = $this -> createMock ( IShare :: class );
$this -> defaultProvider -> method ( 'getAllShares' )
2020-04-09 14:53:40 +03:00
-> willReturnCallback ( function () use ( $share1 , $share2 ) {
2019-10-30 16:27:17 +03:00
yield $share1 ;
yield $share2 ;
});
$extraProvider -> method ( 'getAllShares' )
2020-04-09 14:53:40 +03:00
-> willReturnCallback ( function () use ( $share3 , $share4 ) {
2019-10-30 16:27:17 +03:00
yield $share3 ;
yield $share4 ;
});
// "yield from", used in "getAllShares()", does not reset the keys, so
// "use_keys" has to be disabled to collect all the values while
// ignoring the keys returned by the generator.
$result = iterator_to_array ( $manager -> getAllShares (), $use_keys = false );
$expects = [ $share1 , $share2 , $share3 , $share4 ];
$this -> assertSame ( $expects , $result );
}
2016-01-13 16:21:55 +03:00
}
2016-01-08 16:31:28 +03:00
2016-01-13 16:21:55 +03:00
class DummyFactory implements IProviderFactory {
2016-01-08 16:31:28 +03:00
2016-01-13 16:21:55 +03:00
/** @var IShareProvider */
2016-11-01 14:35:50 +03:00
protected $provider ;
2016-01-08 16:31:28 +03:00
2016-01-20 10:30:37 +03:00
public function __construct ( \OCP\IServerContainer $serverContainer ) {
}
2016-01-08 16:31:28 +03:00
/**
2016-01-13 16:21:55 +03:00
* @ param IShareProvider $provider
2016-01-08 16:31:28 +03:00
*/
2016-01-13 16:21:55 +03:00
public function setProvider ( $provider ) {
$this -> provider = $provider ;
2016-01-08 16:31:28 +03:00
}
/**
2016-01-13 16:21:55 +03:00
* @ param string $id
* @ return IShareProvider
2016-01-08 16:31:28 +03:00
*/
2016-01-13 16:21:55 +03:00
public function getProvider ( $id ) {
return $this -> provider ;
2016-01-08 16:31:28 +03:00
}
/**
2016-01-13 16:21:55 +03:00
* @ param int $shareType
* @ return IShareProvider
2016-01-08 16:31:28 +03:00
*/
2016-01-13 16:21:55 +03:00
public function getProviderForType ( $shareType ) {
return $this -> provider ;
2015-12-15 11:54:12 +03:00
}
2016-06-18 23:04:56 +03:00
/**
* @ return IShareProvider []
*/
public function getAllProviders () {
return [ $this -> provider ];
}
2016-11-01 14:35:50 +03:00
}
2016-06-18 23:04:56 +03:00
2016-11-01 14:35:50 +03:00
class DummyFactory2 extends DummyFactory {
/** @var IShareProvider */
private $provider2 ;
/**
* @ param IShareProvider $provider
*/
public function setSecondProvider ( $provider ) {
$this -> provider2 = $provider ;
}
2016-06-18 23:04:56 +03:00
2016-11-01 14:35:50 +03:00
public function getAllProviders () {
return [ $this -> provider , $this -> provider2 ];
}
2016-05-11 21:48:27 +03:00
}