2021-06-26 15:23:15 +00:00
< ? php
2018-04-14 17:47:13 +00:00
2021-06-26 15:23:15 +00:00
namespace Tests ;
use BookStack\Auth\Permissions\PermissionService ;
use BookStack\Auth\Permissions\PermissionsRepo ;
2021-08-28 20:48:17 +00:00
use BookStack\Auth\Permissions\RolePermission ;
2021-06-26 15:23:15 +00:00
use BookStack\Auth\Role ;
2019-10-05 11:55:01 +00:00
use BookStack\Auth\User ;
2020-11-22 00:17:45 +00:00
use BookStack\Entities\Models\Book ;
use BookStack\Entities\Models\Bookshelf ;
use BookStack\Entities\Models\Chapter ;
use BookStack\Entities\Models\Entity ;
use BookStack\Entities\Models\Page ;
2019-10-05 11:55:01 +00:00
use BookStack\Entities\Repos\BookRepo ;
use BookStack\Entities\Repos\BookshelfRepo ;
use BookStack\Entities\Repos\ChapterRepo ;
2018-10-13 10:27:55 +00:00
use BookStack\Entities\Repos\PageRepo ;
2018-09-25 11:30:50 +00:00
use BookStack\Settings\SettingService ;
2019-07-17 21:36:49 +00:00
use BookStack\Uploads\HttpFetcher ;
2021-06-26 15:23:15 +00:00
use Illuminate\Foundation\Testing\Assert as PHPUnit ;
2021-08-28 20:48:17 +00:00
use Illuminate\Http\JsonResponse ;
2019-09-14 13:12:39 +00:00
use Illuminate\Support\Env ;
2020-05-23 10:26:48 +00:00
use Illuminate\Support\Facades\Log ;
2019-10-05 11:55:01 +00:00
use Mockery ;
2020-05-23 10:26:48 +00:00
use Monolog\Handler\TestHandler ;
use Monolog\Logger ;
2018-04-14 17:47:13 +00:00
trait SharedTestHelpers
{
protected $admin ;
protected $editor ;
/**
* Set the current user context to be an admin .
*/
public function asAdmin ()
{
return $this -> actingAs ( $this -> getAdmin ());
}
/**
* Get the current admin user .
*/
2021-03-03 22:11:00 +00:00
public function getAdmin () : User
{
if ( is_null ( $this -> admin )) {
2018-04-14 17:47:13 +00:00
$adminRole = Role :: getSystemRole ( 'admin' );
$this -> admin = $adminRole -> users -> first ();
}
2021-03-03 22:11:00 +00:00
2018-04-14 17:47:13 +00:00
return $this -> admin ;
}
/**
* Set the current user context to be an editor .
*/
public function asEditor ()
{
return $this -> actingAs ( $this -> getEditor ());
}
/**
* Get a editor user .
*/
2021-03-03 22:11:00 +00:00
protected function getEditor () : User
{
if ( $this -> editor === null ) {
2018-04-14 17:47:13 +00:00
$editorRole = Role :: getRole ( 'editor' );
$this -> editor = $editorRole -> users -> first ();
}
2021-06-26 15:23:15 +00:00
2018-04-14 17:47:13 +00:00
return $this -> editor ;
}
/**
2020-05-23 10:26:48 +00:00
* Get an instance of a user with 'viewer' permissions .
2018-04-14 17:47:13 +00:00
*/
2020-05-23 10:26:48 +00:00
protected function getViewer ( array $attributes = []) : User
2018-04-14 17:47:13 +00:00
{
2019-10-05 11:55:01 +00:00
$user = Role :: getRole ( 'viewer' ) -> users () -> first ();
2020-05-23 10:26:48 +00:00
if ( ! empty ( $attributes )) {
$user -> forceFill ( $attributes ) -> save ();
}
2021-06-26 15:23:15 +00:00
2018-04-14 17:47:13 +00:00
return $user ;
}
2021-05-29 22:42:21 +00:00
/**
* Get a user that ' s not a system user such as the guest user .
*/
2021-09-17 22:44:54 +00:00
public function getNormalUser () : User
2021-05-29 22:42:21 +00:00
{
return User :: query () -> where ( 'system_name' , '=' , null ) -> get () -> last ();
}
2018-09-21 14:15:16 +00:00
/**
* Regenerate the permission for an entity .
*/
2021-03-03 22:11:00 +00:00
protected function regenEntityPermissions ( Entity $entity ) : void
2018-09-21 14:15:16 +00:00
{
2019-09-19 23:18:28 +00:00
$entity -> rebuildPermissions ();
2018-09-21 14:15:16 +00:00
$entity -> load ( 'jointPermissions' );
}
/**
* Create and return a new bookshelf .
*/
2021-03-03 22:11:00 +00:00
public function newShelf ( array $input = [ 'name' => 'test shelf' , 'description' => 'My new test shelf' ]) : Bookshelf
{
2019-10-05 11:55:01 +00:00
return app ( BookshelfRepo :: class ) -> create ( $input , []);
2018-09-21 14:15:16 +00:00
}
2018-04-14 17:47:13 +00:00
/**
* Create and return a new book .
*/
2021-03-03 22:11:00 +00:00
public function newBook ( array $input = [ 'name' => 'test book' , 'description' => 'My new test book' ]) : Book
{
2019-10-05 11:55:01 +00:00
return app ( BookRepo :: class ) -> create ( $input );
2018-04-14 17:47:13 +00:00
}
/**
2021-06-26 15:23:15 +00:00
* Create and return a new test chapter .
2018-04-14 17:47:13 +00:00
*/
2021-03-03 22:11:00 +00:00
public function newChapter ( array $input = [ 'name' => 'test chapter' , 'description' => 'My new test chapter' ], Book $book ) : Chapter
{
2019-10-05 11:55:01 +00:00
return app ( ChapterRepo :: class ) -> create ( $input , $book );
2018-04-14 17:47:13 +00:00
}
/**
2021-06-26 15:23:15 +00:00
* Create and return a new test page .
2018-04-14 17:47:13 +00:00
*/
2021-03-03 22:11:00 +00:00
public function newPage ( array $input = [ 'name' => 'test page' , 'html' => 'My new test page' ]) : Page
{
$book = Book :: query () -> first ();
2018-10-13 10:27:55 +00:00
$pageRepo = app ( PageRepo :: class );
2019-10-05 11:55:01 +00:00
$draftPage = $pageRepo -> getNewDraftPage ( $book );
2021-06-26 15:23:15 +00:00
2019-10-05 11:55:01 +00:00
return $pageRepo -> publishDraft ( $draftPage , $input );
2018-04-14 17:47:13 +00:00
}
/**
* Quickly sets an array of settings .
*/
2021-03-03 22:11:00 +00:00
protected function setSettings ( array $settingsArray ) : void
2018-04-14 17:47:13 +00:00
{
$settings = app ( SettingService :: class );
foreach ( $settingsArray as $key => $value ) {
$settings -> put ( $key , $value );
}
}
/**
* Manually set some permissions on an entity .
*/
2021-03-03 22:11:00 +00:00
protected function setEntityRestrictions ( Entity $entity , array $actions = [], array $roles = []) : void
2018-04-14 17:47:13 +00:00
{
$entity -> restricted = true ;
$entity -> permissions () -> delete ();
$permissions = [];
foreach ( $actions as $action ) {
foreach ( $roles as $role ) {
$permissions [] = [
'role_id' => $role -> id ,
2021-06-26 15:23:15 +00:00
'action' => strtolower ( $action ),
2018-04-14 17:47:13 +00:00
];
}
}
$entity -> permissions () -> createMany ( $permissions );
$entity -> save ();
$entity -> load ( 'permissions' );
$this -> app [ PermissionService :: class ] -> buildJointPermissionsForEntity ( $entity );
$entity -> load ( 'jointPermissions' );
}
2018-09-21 14:15:16 +00:00
/**
* Give the given user some permissions .
*/
2021-03-03 22:11:00 +00:00
protected function giveUserPermissions ( User $user , array $permissions = []) : void
2018-09-21 14:15:16 +00:00
{
$newRole = $this -> createNewRole ( $permissions );
$user -> attachRole ( $newRole );
$user -> load ( 'roles' );
2021-01-02 01:22:41 +00:00
$user -> clearPermissionCache ();
2018-09-21 14:15:16 +00:00
}
2021-08-28 20:48:17 +00:00
/**
* Completely remove the given permission name from the given user .
*/
protected function removePermissionFromUser ( User $user , string $permission )
{
$permission = RolePermission :: query () -> where ( 'name' , '=' , $permission ) -> first ();
/** @var Role $role */
foreach ( $user -> roles as $role ) {
$role -> detachPermission ( $permission );
}
$user -> clearPermissionCache ();
}
2018-09-21 14:15:16 +00:00
/**
* Create a new basic role for testing purposes .
*/
2021-03-03 22:11:00 +00:00
protected function createNewRole ( array $permissions = []) : Role
2018-09-21 14:15:16 +00:00
{
$permissionRepo = app ( PermissionsRepo :: class );
$roleData = factory ( Role :: class ) -> make () -> toArray ();
$roleData [ 'permissions' ] = array_flip ( $permissions );
2021-06-26 15:23:15 +00:00
2018-09-21 14:15:16 +00:00
return $permissionRepo -> saveNewRole ( $roleData );
}
2021-09-13 21:54:21 +00:00
/**
* Create a group of entities that belong to a specific user .
2021-09-15 21:18:37 +00:00
* @ return array { book : Book , chapter : Chapter , page : Page }
2021-09-13 21:54:21 +00:00
*/
protected function createEntityChainBelongingToUser ( User $creatorUser , ? User $updaterUser = null ) : array
{
if ( empty ( $updaterUser )) {
$updaterUser = $creatorUser ;
}
$userAttrs = [ 'created_by' => $creatorUser -> id , 'owned_by' => $creatorUser -> id , 'updated_by' => $updaterUser -> id ];
$book = factory ( Book :: class ) -> create ( $userAttrs );
$chapter = factory ( Chapter :: class ) -> create ( array_merge ([ 'book_id' => $book -> id ], $userAttrs ));
$page = factory ( Page :: class ) -> create ( array_merge ([ 'book_id' => $book -> id , 'chapter_id' => $chapter -> id ], $userAttrs ));
$restrictionService = $this -> app [ PermissionService :: class ];
$restrictionService -> buildJointPermissionsForEntity ( $book );
return compact ( 'book' , 'chapter' , 'page' );
}
2019-07-17 21:36:49 +00:00
/**
* Mock the HttpFetcher service and return the given data on fetch .
*/
protected function mockHttpFetch ( $returnData , int $times = 1 )
{
2019-10-05 11:55:01 +00:00
$mockHttp = Mockery :: mock ( HttpFetcher :: class );
2019-07-17 21:36:49 +00:00
$this -> app [ HttpFetcher :: class ] = $mockHttp ;
$mockHttp -> shouldReceive ( 'fetch' )
-> times ( $times )
-> andReturn ( $returnData );
}
2019-09-14 13:12:39 +00:00
/**
* Run a set test with the given env variable .
* Remembers the original and resets the value after test .
*/
protected function runWithEnv ( string $name , $value , callable $callback )
{
Env :: disablePutenv ();
2019-09-20 00:18:59 +00:00
$originalVal = $_SERVER [ $name ] ? ? null ;
2019-09-14 13:12:39 +00:00
if ( is_null ( $value )) {
unset ( $_SERVER [ $name ]);
} else {
$_SERVER [ $name ] = $value ;
}
$this -> refreshApplication ();
$callback ();
if ( is_null ( $originalVal )) {
unset ( $_SERVER [ $name ]);
} else {
$_SERVER [ $name ] = $originalVal ;
}
}
/**
* Check the keys and properties in the given map to include
* exist , albeit not exclusively , within the map to check .
*/
2021-03-03 22:11:00 +00:00
protected function assertArrayMapIncludes ( array $mapToInclude , array $mapToCheck , string $message = '' ) : void
2019-09-14 13:12:39 +00:00
{
$passed = true ;
foreach ( $mapToInclude as $key => $value ) {
if ( ! isset ( $mapToCheck [ $key ]) || $mapToCheck [ $key ] !== $mapToInclude [ $key ]) {
$passed = false ;
}
}
$toIncludeStr = print_r ( $mapToInclude , true );
$toCheckStr = print_r ( $mapToCheck , true );
self :: assertThat ( $passed , self :: isTrue (), " Failed asserting that given map: \n \n { $toCheckStr } \n \n includes: \n \n { $toIncludeStr } " );
}
2020-02-02 13:10:21 +00:00
/**
* Assert a permission error has occurred .
*/
protected function assertPermissionError ( $response )
{
2021-06-26 15:23:15 +00:00
PHPUnit :: assertTrue ( $this -> isPermissionError ( $response -> baseResponse ? ? $response -> response ), 'Failed asserting the response contains a permission error.' );
2020-11-06 12:54:39 +00:00
}
2020-02-02 13:10:21 +00:00
2020-11-06 12:54:39 +00:00
/**
* Assert a permission error has occurred .
*/
protected function assertNotPermissionError ( $response )
{
2021-06-26 15:23:15 +00:00
PHPUnit :: assertFalse ( $this -> isPermissionError ( $response -> baseResponse ? ? $response -> response ), 'Failed asserting the response does not contain a permission error.' );
2020-11-06 12:54:39 +00:00
}
/**
* Check if the given response is a permission error .
*/
private function isPermissionError ( $response ) : bool
{
return $response -> status () === 302
2021-08-28 20:48:17 +00:00
&& (
(
$response -> headers -> get ( 'Location' ) === url ( '/' )
&& strpos ( session () -> pull ( 'error' , '' ), 'You do not have permission to access' ) === 0
)
||
(
$response instanceof JsonResponse &&
$response -> json ([ 'error' => 'You do not have permission to perform the requested action.' ])
)
);
2020-02-02 13:10:21 +00:00
}
2020-05-23 10:26:48 +00:00
/**
* Set a test handler as the logging interface for the application .
* Allows capture of logs for checking against during tests .
*/
protected function withTestLogger () : TestHandler
{
$monolog = new Logger ( 'testing' );
$testHandler = new TestHandler ();
$monolog -> pushHandler ( $testHandler );
2021-03-03 22:11:00 +00:00
Log :: extend ( 'testing' , function () use ( $monolog ) {
2020-05-23 10:26:48 +00:00
return $monolog ;
});
Log :: setDefaultDriver ( 'testing' );
return $testHandler ;
}
2021-06-26 15:23:15 +00:00
}