lock
1.0.0
Lamento decir que Lock no se mantiene actualmente. No podré ofrecer soporte ni aceptar nuevas contribuciones por el momento. Otras prioridades me impiden poner en Lock el trabajo que se merece. Con el tiempo intentaré retomar el trabajo, pero lamentablemente no puedo decir cuándo. Mi agradecimiento va a todos los contribuyentes y usuarios.
-- Se seca
Lock es un paquete Acl flexible basado en controladores para PHP 5.4+ .
Creado por Dries Vints. Hecho posible gracias a BeatSwitch. Inspirado en Autoridad de Matthew Machuga. Logotipo de Jerry Low.
Lock : una instancia de ACL para un sujeto. Este paquete actualmente se envía con un CallerLock y un RoleLockCaller : un objeto de identidad que puede tener permisos para hacer algo.Driver : un sistema de almacenamiento de permisos que puede ser estático o persistente.Permission : un permiso contiene una acción y un recurso opcional (único). Puede ser una Restriction o un PrivilegeRestriction : una restricción le impide realizar una acción (en un recurso opcional)Privilege : un privilegio le permite realizar una acción (en un recurso opcional)Action : Una acción es algo que se le permite o se le niega hacer.Resource : un recurso puede ser un objeto sobre el que puede realizar una o más acciones. Puede apuntar a un determinado tipo de recurso o a un recurso específico mediante su identificador único.Role : un rol también puede tener múltiples permisos. Una persona que llama puede tener múltiples roles. Los roles pueden heredar permisos de otros roles. Lock se diferencia de otros paquetes de acl al intentar proporcionar la forma más flexible de trabajar con múltiples llamadores de permisos y almacenar permisos.
Al trabajar con el contrato Caller de Lock, puede establecer permisos para múltiples identidades.
El contrato Driver permite una forma sencilla de almacenar permisos en un sistema de almacenamiento persistente o estático. Con este paquete se incluye un ArrayDriver estático predeterminado. Consulte la lista a continuación para conocer más controladores que ya se han preparado para usted. O cree el suyo propio implementando el contrato Driver .
Puede establecer y verificar permisos para recursos pasando manualmente el tipo de recurso y el identificador (opcional) o puede implementar el contrato Resource en sus objetos para poder pasarlos y bloquearlos más fácilmente.
El Manager permite una manera fácil de crear instancias de nuevas instancias Lock , establecer alias de acciones o registrar roles.
Si necesita una implementación específica del marco, elija uno de los controladores ya preparados a continuación.
Instale este paquete a través de Composer.
$ composer require beatswitch/lock Cada identidad que debería tener permisos para hacer algo debe implementar el contrato BeatSwitchLockCallersCaller . El contrato Caller identifica a la persona que llama exigiéndole que devuelva su tipo y su identificador único. Veamos un ejemplo a continuación.
<?php
use BeatSwitch Lock Callers Caller ;
class User implements Caller
{
public function getCallerType ()
{
return ' users ' ;
}
public function getCallerId ()
{
return $ this -> id ;
}
public function getCallerRoles ()
{
return [ ' editor ' , ' publisher ' ];
}
} Al agregar la función getCallerType podemos identificar un grupo de personas que llaman a través de un tipo único. Si en algún momento quisiéramos establecer permisos en otro grupo de personas que llaman, podríamos implementar fácilmente el contrato en otro objeto.
<?php
use BeatSwitch Lock Callers Caller ;
class Organization implements Caller
{
public function getCallerType ()
{
return ' organizations ' ;
}
public function getCallerId ()
{
return $ this -> id ;
}
public function getCallerRoles ()
{
return [ ' enterprise ' ];
}
}Y así podemos recuperar fácilmente permisos para un tipo de persona que llama específico a través de un controlador.
Si desea configurar todos sus permisos de antemano, puede utilizar el ArrayDriver estático que se incluye con el paquete. Esto le permite establecer una lista de permisos para una persona que llama antes de que se ejecute su aplicación.
use BeatSwitch Lock Drivers ArrayDriver ;
use BeatSwitch Lock Lock ;
use BeatSwitch Lock Manager ;
// Create a new Manager instance.
$ manager = new Manager ( new ArrayDriver ());
// Instantiate a new Lock instance for an object which implements the Caller contract.
$ lock = $ manager -> caller ( $ caller );
// Set some permissions.
$ lock -> allow ( ' manage_settings ' );
$ lock -> allow ( ' create ' , ' events ' );
// Use the Lock instance to validate permissions on the given caller.
$ lock -> can ( ' manage_settings ' ); // true: can manage settings
$ lock -> can ( ' create ' , ' events ' ); // true: can create events
$ lock -> cannot ( ' update ' , ' events ' ); // true: cannot update events
$ lock -> can ( ' delete ' , ' events ' ); // false: cannot delete eventsTrabajar con un controlador persistente le permite almacenar permisos en una capa de almacenamiento persistente y ajustarlos durante el tiempo de ejecución. Por ejemplo, si implementara el controlador Laravel 5, almacenaría los permisos en una base de datos utilizando el componente de base de datos de Laravel. Al crear su propia interfaz de usuario, puede adjuntar fácilmente la funcionalidad acl de este paquete para crear, por ejemplo, un sistema de administración de usuarios donde diferentes usuarios tienen diferentes permisos.
Echemos un vistazo a un controlador de gestión de usuarios muy básico para ver cómo se hace. Asumiremos que tenemos una instancia de administrador de bloqueo arrancada con nuestro controlador Laravel DB.
<?php
use BeatSwitch Lock Manager ;
class UserManagementController extends BaseController
{
protected $ lockManager ;
public function __construct ( Manager $ lockManager )
{
$ this -> lockManager = $ lockManager ;
}
public function togglePermission ()
{
$ userId = Input:: get ( ' user ' );
$ action = Input:: get ( ' action ' );
$ resource = Input:: get ( ' resource ' );
$ user = User:: find ( $ userId );
$ this -> lockManager -> caller ( $ user )-> toggle ( $ action , $ resource );
return Redirect:: route ( ' user_management ' );
}
} Cada vez que se utiliza el método togglePermission , se alternará el permiso del usuario para la acción y el tipo de recurso determinados.
Puede allow o deny que la persona que llama haga algo. Aquí hay un par de formas de configurar y verificar permisos.
Permita que una persona que llama cree todo.
$ lock -> allow ( ' create ' );
$ lock -> can ( ' create ' ); // truePermitir que una persona que llama solo cree publicaciones.
$ lock -> allow ( ' create ' , ' posts ' );
$ lock -> can ( ' create ' ); // false
$ lock -> can ( ' create ' , ' posts ' ); // truePermita que una persona que llama edite solo una publicación específica con un ID de 5.
$ lock -> allow ( ' edit ' , ' posts ' , 5 );
$ lock -> can ( ' edit ' ); // false
$ lock -> can ( ' edit ' , ' posts ' ); // false
$ lock -> can ( ' edit ' , ' posts ' , 5 ); // truePermita que una persona que llama edite todas las publicaciones, pero niegue que edite una con la identificación de 5.
$ lock -> allow ( ' edit ' , ' posts ' );
$ lock -> deny ( ' edit ' , ' posts ' , 5 );
$ lock -> can ( ' edit ' , ' posts ' ); // true
$ lock -> can ( ' edit ' , ' posts ' , 5 ); // falseAlternar el valor de un permiso.
$ lock -> allow ( ' create ' );
$ lock -> can ( ' create ' ); // true
$ lock -> toggle ( ' create ' );
$ lock -> can ( ' create ' ); // falsePuede permitir o denegar varias acciones a la vez y también marcar varias acciones a la vez.
$ lock -> allow ([ ' create ' , ' edit ' ], ' posts ' );
$ lock -> can ( ' create ' , ' posts ' ); // true
$ lock -> can ([ ' create ' , ' edit ' ], ' posts ' ); // true
$ lock -> can ([ ' create ' , ' delete ' ], ' posts ' ); // falsePuede borrar fácilmente permisos para una combinación específica de acciones y recursos.
$ lock -> allow ([ ' create ' , ' edit ' ], ' posts ' );
$ lock -> clear ( ' edit ' , ' posts ' );
$ lock -> can ( ' edit ' , ' posts ' ); // false
$ lock -> can ( ' create ' , ' posts ' ); // trueTambién puede borrar todos los permisos para una instancia de bloqueo.
$ lock -> allow ( ' manage-posts ' );
$ lock -> allow ([ ' create ' , ' edit ' ], ' users ' );
$ lock -> clear ();
$ lock -> can ( ' manage-posts ' ); // false
$ lock -> can ( ' create ' , ' users ' ); // falsePara agrupar varias acciones y configurarlas todas a la vez, es posible que desees establecer un alias de acción.
$ lock -> alias ( ' manage ' , [ ' create ' , ' read ' , ' delete ' ]);
$ lock -> allow ( ' manage ' , ' posts ' );
$ lock -> can ( ' manage ' , ' posts ' ); // true
$ lock -> can ( ' create ' , ' posts ' ); // true
$ lock -> can ( ' delete ' , ' posts ' , 1 ); // true
$ lock -> can ( ' update ' , ' posts ' ); // false Puede configurar fácilmente una persona que llama que tenga todos los permisos para todo pasando el comodín all como una acción en la instancia de bloqueo.
$ lock -> allow ( ' all ' );Ahora cada llamada al método "can" se validará como verdadera para esta persona que llama.
Lock proporciona una forma sencilla de trabajar con roles. Puede trabajar con roles listos para usar, pero si desea trabajar con herencia, deberá registrar los roles en la instancia del administrador.
$ manager -> setRole ( ' guest ' );
$ manager -> setRole ( ' user ' , ' guest ' ); // "user" will inherit all permissions from "guest"O registre varios roles a la vez.
$ manager -> setRole ([ ' editor ' , ' admin ' ], ' user ' ); // "editor" and "admin" will inherit all permissions from "user".Configuremos algunos permisos y veamos cómo se resuelven.
// Allow a guest to read everything.
$ manager -> role ( ' guest ' )-> allow ( ' guest ' , ' read ' );
// Allow a user to create posts.
$ manager -> role ( ' user ' )-> allow ( ' create ' , ' posts ' );
// Allow an editor and admin to publish posts.
$ manager -> role ( ' editor ' )-> allow ( ' publish ' , ' posts ' );
$ manager -> role ( ' admin ' )-> allow ( ' publish ' , ' posts ' );
// Allow an admin to delete posts.
$ manager -> role ( ' admin ' )-> allow ( ' delete ' , ' posts ' );
// Let's assume our caller has the role of "editor" and check some permissions.
$ lock = $ manager -> caller ( $ caller );
$ lock -> can ( ' read ' ); // true
$ lock -> can ( ' delete ' , ' posts ' ); // false
$ lock -> can ( ' publish ' ); // false: we can't publish everything, just posts.
$ lock -> can ([ ' create ' , ' publish ' ], ' posts ' ); // trueAlgo que debe tener en cuenta es que los permisos a nivel de persona que llama reemplazan a los permisos a nivel de función. Veamos cómo funciona.
Nuestro interlocutor tendrá el rol de usuario.
$ manager -> caller ( $ caller )-> allow ( ' create ' , ' posts ' );
// Notice that we don't need to set the role in the
// manager first if we don't care about inheritance.
$ manager -> role ( ' user ' )-> deny ( ' user ' , ' create ' , ' posts ' );
$ manager -> caller ( $ caller )-> can ( ' create ' , ' posts ' ); // true: the user has explicit permission to create posts. Las condiciones son en realidad afirmaciones que son comprobaciones adicionales que puede establecer para los permisos. Puede pasar una matriz con ellos como último parámetro de allow y deny . Todas las condiciones deben implementar la interfaz BeatSwitchLockPermissionsCondition .
Advertencia: tenga en cuenta que las condiciones actualmente solo funcionan con controladores estáticos.
Establezcamos una condición.
<?php
use BeatSwitch Lock Lock ;
use BeatSwitch Lock Permissions Condition ;
use BeatSwitch Lock Permissions Permission ;
use BeatSwitch Lock Resources Resource ;
use Illuminate Auth AuthManager ;
class LoggedInCondition implements Condition
{
/**
* The Laravel AuthManager instance
*
* @var IlluminateAuthAuthManager
*/
protected $ auth ;
/**
* @param IlluminateAuthAuthManager $auth
*/
public function __construct ( AuthManager $ auth )
{
$ this -> auth = $ auth ;
}
/**
* Assert if the condition is correct
*
* @param BeatSwitchLockLock $lock The current Lock instance that's being used
* @param BeatSwitchLockPermissionsPermission $permission The Permission that's being checked
* @param string $action The action passed to the can or cannot method
* @param BeatSwitchLockResourcesResource|null $resource The resource passed to the can or cannot method
* @return bool
*/
public function assert ( Lock $ lock , Permission $ permission , $ action , Resource $ resource = null )
{
// Condition will succeed if the user is logged in.
return $ this -> auth -> check ();
}
}Ahora veamos cómo funcionará esto al configurar un permiso.
$ condition = App:: make ( ' LoggedInCondition ' );
$ lock -> allow ( ' create ' , ' posts ' , null , $ condition );
$ lock -> can ( ' create ' , ' posts ' ); // true if logged in, otherwise false.También puede transmitir varias condiciones.
$ lock -> allow ( ' create ' , ' posts ' , null , [ $ falseCondition , $ trueCondition ]);
$ lock -> can ( ' create ' , ' posts ' ); // false: there's at least one false conditionPuede transmitir tantas condiciones como desee, pero todas deben cumplirse para que el permiso funcione.
También puedes utilizar una devolución de llamada si lo deseas.
$ lock -> allow ( ' create ' , ' posts ' , null , function ( $ lock , $ permission , $ action , $ resource = null ) {
return false ;
});
$ lock -> can ( ' create ' , ' posts ' ); // false because the callback returns false. Si desea recuperar una lista de recursos a los que se les permite o deniega realizar una acción en particular, puede utilizar los métodos allowed y denied en una instancia Lock .
$ lock -> allow ( ' update ' , ' users ' , 1 );
$ lock -> allow ( ' update ' , ' users ' , 2 );
$ lock -> allow ( ' update ' , ' users ' , 3 );
$ lock -> deny ( ' update ' , ' users ' , 2 );
$ lock -> allowed ( ' update ' , ' users ' ); // Returns [1, 3];
$ lock -> denied ( ' update ' , ' users ' ); // Returns [2];Tenga en cuenta que solo puede recuperar identificaciones de recursos que tengan permisos establecidos. Los recursos que no estén registrados a través de Lock no serán devueltos.
Puede agregar fácilmente la funcionalidad ACL a su interlocutor o rol implementando el rasgo BeatSwitchLockLockAware .
<?php
use BeatSwitch Lock Callers Caller ;
use BeatSwitch Lock LockAware ;
class Organization implements Caller
{
use LockAware;
public function getCallerType ()
{
return ' organizations ' ;
}
public function getCallerId ()
{
return $ this -> id ;
}
public function getCallerRoles ()
{
return [ ' enterprise ' ];
}
}Ahora necesitamos configurar su instancia de bloqueo.
$ caller -> setLock ( $ lock );Y ahora la persona que llama puede usar todos los métodos de bloqueo sobre sí misma.
$ caller -> can ( ' create ' , ' posts ' );
$ caller -> allow ( ' edit ' , ' pages ' ); Si tiene una persona que llama que implementa el rasgo LockAware pero aún no ha iniciado la instancia de bloqueo de la persona que llama, puede hacer que la persona que llama esté consciente del bloqueo usando el método makeCallerLockAware del administrador.
$ caller = $ manager -> makeCallerLockAware ( $ caller ); Y ahora la persona que llama podrá utilizar los métodos LockAware . Existe un método similar para los roles.
$ role = $ manager -> makeRoleLockAware ( ' guest ' ); Esto iniciará un objeto SimpleRole que ya viene con el rasgo LockAware implementado.
Todos los siguientes métodos se pueden invocar en una instancia de BeatSwitchLockLock .
Comprueba si la persona que llama actualmente tiene permiso para hacer algo.
can(
string|array $action,
string|BeatSwitchLockResourcesResource $resource = null,
int $resourceId = null
)
Comprueba si está prohibido que la persona que llama haga algo.
cannot(
string|array $action,
string|BeatSwitchLockResourcesResource $resource = null,
int $resourceId = null
)
Establece un permiso Privilege en una persona que llama para permitirle hacer algo. Elimina cualquier restricción de coincidencia.
allow(
string|array $action,
string|BeatSwitchLockResourcesResource $resource = null,
int $resourceId = null,
BeatSwitchLockPermissionsCondition[] $conditions = []
)
Establece un permiso Restriction en una persona que llama para evitar que haga algo. Elimina cualquier privilegio coincidente.
deny(
string|array $action,
string|BeatSwitchLockResourcesResource $resource = null,
int $resourceId = null,
BeatSwitchLockPermissionsCondition[] $conditions = []
)
Alterna el valor del permiso otorgado.
toggle(
string|array $action,
string|BeatSwitchLockResourcesResource $resource = null,
int $resourceId = null
)
Devuelve todas las identificaciones en una matriz del tipo de recurso dado en el que el sujeto puede realizar la acción dada.
allowed(
string|array $action,
string|BeatSwitchLockResourcesResource $resourceType
)
Devuelve todas las identificaciones en una matriz del tipo de recurso dado al cual se le niega al sujeto realizar la acción dada.
denied(
string|array $action,
string|BeatSwitchLockResourcesResource $resourceType
)
Todos los siguientes métodos se pueden invocar en una instancia de BeatSwitchLockManager .
Devuelve una instancia BeatSwitchLockLock para una persona que llama.
caller(
BeatSwitchLockCallersCaller $caller
)
Devuelve una instancia BeatSwitchLockLock para un rol.
role(
BeatSwitchLockRolesRole $role
)
Agregue un alias para una o más acciones.
alias(
string $name,
string|array $actions
)
Establezca uno o más roles y un rol opcional del que heredar permisos.
setRole(
string|array $name,
string $inherit = null
)
Establece la instancia de bloqueo para una persona que llama que implementa el rasgo LockAware . Devuelve la persona que llama con la instancia de bloqueo configurada.
makeCallerLockAware(
BeatSwitchLockCallersCaller $caller
)
Establece la instancia de bloqueo para una función que implementa el rasgo LockAware . Devuelve el rol con la instancia de bloqueo establecida.
makeRoleLockAware(
BeatSwitchLockRolesRole|string $role
)
Puede crear fácilmente un controlador implementando el contrato BeatSwitchLockDriversDriver . A continuación, demostraremos cómo crear nuestro propio controlador persistente utilizando Eloquent ORM de Laravel como nuestro mecanismo de almacenamiento.
Supondremos que tenemos una clase de modelo CallerPermission con al menos las siguientes columnas de base de datos:
caller_type (varchar, 100)caller_id (int, 11)type (varchar, 10)action (varchar, 100)resource_type (varchar, 100, anulable)resource_id (int, 11, anulable) Y tenemos un modelo RolePermission con las siguientes columnas de base de datos:
role (varchar, 100)type (varchar, 10)action (varchar, 100)resource_type (varchar, 100, anulable)resource_id (int, 11, anulable) Veamos una implementación completa del controlador a continuación. Observe que para el método getCallerPermissions estamos usando la clase PermissionFactory para mapear fácilmente los datos y crear objetos Permission a partir de ellos. El método createFromData de PermissionFactory aceptará tanto matrices como objetos.
<?php
use BeatSwitch Lock Callers Caller ;
use BeatSwitch Lock Drivers Driver ;
use BeatSwitch Lock Permissions Permission ;
use BeatSwitch Lock Permissions PermissionFactory ;
use BeatSwitch Lock Roles Role ;
use CallerPermission ;
use RolePermission ;
class EloquentDriver implements Driver
{
/**
* Returns all the permissions for a caller
*
* @param BeatSwitchLockCallersCaller $caller
* @return BeatSwitchLockPermissionsPermission[]
*/
public function getCallerPermissions ( Caller $ caller )
{
$ permissions = CallerPermission:: where ( ' caller_type ' , $ caller -> getCallerType ())
-> where ( ' caller_id ' , $ caller -> getCallerId ())
-> get ();
return PermissionFactory:: createFromData ( $ permissions -> toArray ());
}
/**
* Stores a new permission into the driver for a caller
*
* @param BeatSwitchLockCallersCaller $caller
* @param BeatSwitchLockPermissionsPermission
* @return void
*/
public function storeCallerPermission ( Caller $ caller , Permission $ permission )
{
$ eloquentPermission = new CallerPermission ;
$ eloquentPermission -> caller_type = $ caller -> getCallerType ();
$ eloquentPermission -> caller_id = $ caller -> getCallerId ();
$ eloquentPermission -> type = $ permission -> getType ();
$ eloquentPermission -> action = $ permission -> getAction ();
$ eloquentPermission -> resource_type = $ permission -> getResourceType ();
$ eloquentPermission -> resource_id = $ permission -> getResourceId ();
$ eloquentPermission -> save ();
}
/**
* Removes a permission from the driver for a caller
*
* @param BeatSwitchLockCallersCaller $caller
* @param BeatSwitchLockPermissionsPermission
* @return void
*/
public function removeCallerPermission ( Caller $ caller , Permission $ permission )
{
CallerPermission:: where ( ' caller_type ' , $ caller -> getCallerType ())
-> where ( ' caller_id ' , $ caller -> getCallerId ())
-> where ( ' type ' , $ permission -> getType ())
-> where ( ' action ' , $ permission -> getAction ())
-> where ( ' resource_type ' , $ permission -> getResourceType ())
-> where ( ' resource_id ' , $ permission -> getResourceId ())
-> delete ();
}
/**
* Checks if a permission is stored for a user
*
* @param BeatSwitchLockCallersCaller $caller
* @param BeatSwitchLockPermissionsPermission
* @return bool
*/
public function hasCallerPermission ( Caller $ caller , Permission $ permission )
{
return ( bool ) CallerPermission:: where ( ' caller_type ' , $ caller -> getCallerType ())
-> where ( ' caller_id ' , $ caller -> getCallerId ())
-> where ( ' type ' , $ permission -> getType ())
-> where ( ' action ' , $ permission -> getAction ())
-> where ( ' resource_type ' , $ permission -> getResourceType ())
-> where ( ' resource_id ' , $ permission -> getResourceId ())
-> first ();
}
/**
* Returns all the permissions for a role
*
* @param BeatSwitchLockRolesRole $role
* @return BeatSwitchLockPermissionsPermission[]
*/
public function getRolePermissions ( Role $ role )
{
$ permissions = RolePermission:: where ( ' role ' , $ role -> getRoleName ())-> get ();
return PermissionFactory:: createFromData ( $ permissions -> toArray ());
}
/**
* Stores a new permission for a role
*
* @param BeatSwitchLockRolesRole $role
* @param BeatSwitchLockPermissionsPermission
* @return void
*/
public function storeRolePermission ( Role $ role , Permission $ permission )
{
$ eloquentPermission = new RolePermission ;
$ eloquentPermission -> role = $ role -> getRoleName ();
$ eloquentPermission -> type = $ permission -> getType ();
$ eloquentPermission -> action = $ permission -> getAction ();
$ eloquentPermission -> resource_type = $ permission -> getResourceType ();
$ eloquentPermission -> resource_id = $ permission -> getResourceId ();
$ eloquentPermission -> save ();
}
/**
* Removes a permission for a role
*
* @param BeatSwitchLockRolesRole $role
* @param BeatSwitchLockPermissionsPermission
* @return void
*/
public function removeRolePermission ( Role $ role , Permission $ permission )
{
RolePermission:: where ( ' role ' , $ role -> getRoleName ())
-> where ( ' type ' , $ permission -> getType ())
-> where ( ' action ' , $ permission -> getAction ())
-> where ( ' resource_type ' , $ permission -> getResourceType ())
-> where ( ' resource_id ' , $ permission -> getResourceId ())
-> delete ();
}
/**
* Checks if a permission is stored for a role
*
* @param BeatSwitchLockRolesRole $role
* @param BeatSwitchLockPermissionsPermission
* @return bool
*/
public function hasRolePermission ( Role $ role , Permission $ permission )
{
return ( bool ) RolePermission:: where ( ' role ' , $ role -> getRoleName ())
-> where ( ' type ' , $ permission -> getType ())
-> where ( ' action ' , $ permission -> getAction ())
-> where ( ' resource_type ' , $ permission -> getResourceType ())
-> where ( ' resource_id ' , $ permission -> getResourceId ())
-> first ();
}
} Tenga en cuenta que no comprobamos si el permiso ya existe cuando intentamos almacenarlo. No necesita preocuparse por eso porque todo eso se hizo por usted en la instancia Lock .
Ahora tenemos un controlador que admite el almacenamiento de permisos para personas que llaman y roles.
Es muy fácil para usted asegurarse de que su controlador funcione como se espera. Si está creando un controlador persistente, puede probarlo fácilmente creando una prueba PHPUnit que extienda la clase PersistentDriverTestCase .
<?php
use BeatSwitch Lock Tests PersistentDriverTestCase ;
class EloquentDriverTest extends PersistentDriverTestCase
{
public function setUp ()
{
// Don't forget to reset your DB here.
// Bootstrap your driver.
$ this -> driver = new EloquentDriver ();
parent :: setUp ();
}
} ¡Y esto es todo lo que necesitas! PersistentDriverTestCase contiene todas las pruebas que necesitará para asegurarse de que su controlador funcione como se esperaba. Entonces, si todas esas pruebas pasan, entonces su controlador se configuró correctamente. No hay necesidad de burlarse de nada, este es un caso de prueba de integración pura. Por supuesto, en este ejemplo específico anterior, para que Eloquent funcione necesitarás iniciar Laravel. Trabajar con una base de datos como sqlite sería la mejor manera de probar su controlador.
El bloqueo no se mantiene en este momento.
Este paquete lo mantiene actualmente Dries Vints.
Si tiene alguna pregunta, no dude en hacerla en un número.
Consulte el archivo de contribución para obtener más detalles.
Puede ver una lista de cambios para cada versión en nuestro archivo de registro de cambios.
La licencia MIT. Consulte el archivo de licencia para obtener más información.
