├── .gitignore
├── .php_cs
├── .travis.yml
├── LICENSE
├── README.md
├── composer.json
├── config
    └── passwordless.php
├── lang
    └── en
    │   └── errors.php
├── migrations
    └── 2016_11_21_121642_create_user_tokens_migration.php
├── phpunit.xml
├── src
    ├── Exceptions
    │   └── InvalidTokenException.php
    ├── Models
    │   └── Token.php
    ├── Providers
    │   └── PasswordlessProvider.php
    └── Traits
    │   └── Passwordless.php
└── tests
    ├── PasswordlessTraitTest.php
    └── TokenTest.php


/.gitignore:
--------------------------------------------------------------------------------
1 | vendor/
2 | composer.lock
3 | 


--------------------------------------------------------------------------------
/.php_cs:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Symfony\CS\Config\Config;
 4 | use Symfony\CS\FixerInterface;
 5 | use Symfony\CS\Finder\DefaultFinder;
 6 | 
 7 | $fixers = [
 8 |     'blankline_after_open_tag',
 9 |     'braces',
10 |     'concat_without_spaces',
11 |     'double_arrow_multiline_whitespaces',
12 |     'duplicate_semicolon',
13 |     'elseif',
14 |     'empty_return',
15 |     'encoding',
16 |     'eof_ending',
17 |     'extra_empty_lines',
18 |     'function_call_space',
19 |     'function_declaration',
20 |     'include',
21 |     'indentation',
22 |     'join_function',
23 |     'line_after_namespace',
24 |     'linefeed',
25 |     'list_commas',
26 |     'logical_not_operators_with_successor_space',
27 |     'lowercase_constants',
28 |     'lowercase_keywords',
29 |     'method_argument_space',
30 |     'multiline_array_trailing_comma',
31 |     'multiline_spaces_before_semicolon',
32 |     'multiple_use',
33 |     'namespace_no_leading_whitespace',
34 |     'no_blank_lines_after_class_opening',
35 |     'no_empty_lines_after_phpdocs',
36 |     'object_operator',
37 |     'operators_spaces',
38 |     'parenthesis',
39 |     'phpdoc_indent',
40 |     'phpdoc_inline_tag',
41 |     'phpdoc_no_access',
42 |     'phpdoc_no_package',
43 |     'phpdoc_scalar',
44 |     'phpdoc_short_description',
45 |     'phpdoc_to_comment',
46 |     'phpdoc_trim',
47 |     'phpdoc_type_to_var',
48 |     'phpdoc_var_without_name',
49 |     'remove_leading_slash_use',
50 |     'remove_lines_between_uses',
51 |     'return',
52 |     'self_accessor',
53 |     'short_array_syntax',
54 |     'short_echo_tag',
55 |     'short_tag',
56 |     'single_array_no_trailing_comma',
57 |     'single_blank_line_before_namespace',
58 |     'single_line_after_imports',
59 |     'single_quote',
60 |     'spaces_before_semicolon',
61 |     'spaces_cast',
62 |     'standardize_not_equal',
63 |     'ternary_spaces',
64 |     'trailing_spaces',
65 |     'trim_array_spaces',
66 |     'unalign_equals',
67 |     'unary_operators_spaces',
68 |     'unused_use',
69 |     'visibility',
70 |     'whitespacy_lines',
71 | ];
72 | 
73 | return Config::create()
74 |     ->finder(DefaultFinder::create()->in(__DIR__))
75 |     ->fixers($fixers)
76 |     ->level(FixerInterface::NONE_LEVEL)
77 | ->setUsingCache(true);


--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
 1 | language: php
 2 | 
 3 | php:
 4 |   - 5.6
 5 |   - 7.0
 6 |   - 7.1
 7 | 
 8 | sudo: true
 9 | 
10 | install:
11 |   - travis_retry composer install --no-interaction --prefer-source
12 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2016 RAFIE Younes
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | # Laravel Passwordless
  2 | 
  3 | Passwordless authentication for Laravel 5
  4 | 
  5 | <p>
  6 |     <a href="https://travis-ci.org/Whyounes/laravel-passwordless-auth">
  7 |         <img src="https://travis-ci.org/Whyounes/laravel-passwordless-auth.svg?branch=master" alt="Build status" />
  8 |     </a>
  9 |     <a href="https://insight.sensiolabs.com/projects/8c7964bf-58d5-4229-928b-d57010f71977">
 10 |         <img src="https://insight.sensiolabs.com/projects/8c7964bf-58d5-4229-928b-d57010f71977/mini.png" />
 11 |     </a>
 12 | </p>
 13 | 
 14 | ## Installation
 15 | 
 16 | Add the package to your project using Composer:
 17 | 
 18 | ```bash
 19 | composer require whyounes/laravel-passwordless-auth
 20 | ```
 21 | 
 22 | Publish package assets:
 23 | 
 24 | ```php
 25 | php artisan vandor:publish
 26 | ```
 27 | 
 28 | Run the migration to create the tokens table:
 29 | 
 30 | ```php
 31 | php artisan migrate
 32 | ```
 33 | 
 34 | Add it to you providers list:
 35 | 
 36 | ```php
 37 | // config/app.php
 38 | 
 39 | // ...
 40 | 'providers' => [
 41 |     // ...
 42 |     Whyounes\Passwordless\Providers\PasswordlessProvider::class,
 43 | };
 44 | ```
 45 | 
 46 | Add the `Passwordless` trait to your user model:
 47 | 
 48 | ```php
 49 | // app/User.php
 50 | 
 51 | class User extends Authenticatable
 52 | {
 53 |     use Whyounes\Passwordless\Traits\Passwordless;
 54 | 
 55 |     // ...
 56 | }
 57 | ```
 58 | 
 59 | ## Configurations
 60 | 
 61 | If you don't want to use the user email along with the token, you can change it by overriding the following method:
 62 | 
 63 | ```php
 64 | // app/User.php
 65 | 
 66 | class User extends Authenticatable
 67 | {
 68 |     use Whyounes\Passwordless\Traits\Passwordless;
 69 | 
 70 |     // ...
 71 |     
 72 |     protected function getIdentifierKey()
 73 |     {
 74 |         return 'email';
 75 |     }
 76 | }
 77 | ```
 78 | 
 79 | You can change the expiration time inside the `config/passwordless.php` file:
 80 | 
 81 | ```php
 82 | // config/passwordless.php
 83 | 
 84 | return [
 85 |     'expire_in' => 15, // Minutes
 86 |     'empty_tokens_after_login' => true // Empty user tokens after login
 87 | ];
 88 | ```
 89 | 
 90 | You can set the `empty_tokens_after_login` config to false if you don't want to delete unused tokens from DB.
 91 | 
 92 | ## Example
 93 | 
 94 | Display the login form for user to type the email:
 95 | 
 96 | ```php
 97 | // routes/web.php
 98 | 
 99 | Route::post('/login/direct', function() {
100 |     return view('login.direct');
101 | });
102 | ```
103 | 
104 | Catch the form submission:
105 | 
106 | ```php
107 | // routes/web.php
108 | 
109 | Route::post('/login/direct', function(Request $request) {
110 |     // send link to user mail
111 |     $user = App\User::where('email', $request->get('email'))->first();
112 |     if (!$user) {
113 |         return redirect()->back(404)->with('error', 'User not found');
114 |     }
115 | 
116 |     // generate token and save it
117 |     $token = $user->generateToken(true);
118 | 
119 |     // send email to user
120 |     \Mail::send("mails.login", ['token' => $token], function($message) use($token) {
121 |         $message->to($token->user->email);
122 |     });
123 | });
124 | ```
125 | 
126 | Catch the login link request:
127 | 
128 | ```php
129 | // routes/web.php
130 | 
131 | Route::get('/login/{token}', function(Request $request, $token) {
132 |     $user = App\User::where('email', $request->get('email'))->first();
133 | 
134 |     if (!$user) {
135 |         dd('User not found');
136 |     }
137 | 
138 |     if($user->isValidToken($token))
139 |     {
140 |         // Login user
141 |         Auth::login($user);
142 |     } else {
143 |         dd("Invalid token");
144 |     }
145 | });
146 | ```
147 | 
148 | Or, if you like working with exceptions:
149 | 
150 | ```php
151 | // routes/web.php
152 | 
153 | Route::get('/login/{token}', function(Request $request, $token) {
154 |     try {
155 |         $user = App\User::where('email', $request->get('email'))->firstOrFail();
156 |         $user->validateToken($token);
157 | 
158 |         Auth::login($user);
159 |     } catch(Illuminate\Database\Eloquent\ModelNotFoundException $ex) {
160 |         dd('User not found');
161 |     } catch(Whyounes\Passwordless\Exceptions\InvalidTokenException $ex) {
162 |         dd("Invalid token");
163 |     }
164 | });
165 | ```
166 | 


--------------------------------------------------------------------------------
/composer.json:
--------------------------------------------------------------------------------
 1 | {
 2 |     "name": "whyounes/laravel-passwordless-auth",
 3 |     "type": "library",
 4 |     "description": "Laravel passwordless authentication for Laravel",
 5 |     "keywords": [
 6 |         "auth",
 7 |         "passwordless"
 8 |     ],
 9 |     "homepage": "https://github.com/whyounes/laravel-passwordless-auth",
10 |     "license": "MIT",
11 |     "authors": [
12 |         {
13 |             "name": "Rafie Younes",
14 |             "email": "younes.rafie@gmail.com",
15 |             "homepage": "http://younesrafie.com",
16 |             "role": "Developer"
17 |         }
18 |     ],
19 |     "require": {
20 |         "php": "^5.5.9 || ^7.0",
21 |         "illuminate/database": "5.1.* || 5.2.* || 5.3.*",
22 |         "illuminate/config": "5.1.* || 5.2.* || 5.3.*",
23 |         "illuminate/events": "5.1.* || 5.2.* || 5.3.*"
24 |     },
25 |     "require-dev": {
26 |         "phpunit/phpunit": "^4.8 || ^5.0",
27 |         "orchestra/testbench": "~3.0",
28 |         "mockery/mockery": "~0.9.4"
29 |     },
30 |     "autoload": {
31 |         "psr-4": {
32 |             "Whyounes\\Passwordless\\": "src"
33 |         },
34 |         "classmap": [
35 |             "tests"
36 |         ]
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/config/passwordless.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | return [
4 |     'expire_in'                => 15, // Minutes
5 |     'empty_tokens_after_login' => false // Empty user tokens after login
6 | ];
7 | 


--------------------------------------------------------------------------------
/lang/en/errors.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | return [
4 |     "invalid_token" => "Invalid token",
5 | ];
6 | 


--------------------------------------------------------------------------------
/migrations/2016_11_21_121642_create_user_tokens_migration.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Illuminate\Database\Migrations\Migration;
 4 | use Illuminate\Database\Schema\Blueprint;
 5 | use Illuminate\Support\Facades\Schema;
 6 | 
 7 | class CreateUserTokensMigration extends Migration
 8 | {
 9 | 
10 |     /**
11 |      * Run the migrations.
12 |      *
13 |      * @return void
14 |      */
15 |     public function up()
16 |     {
17 |         Schema::create(
18 |             'user_tokens', function (Blueprint $table) {
19 |             $table->increments('id');
20 |             $table->string('token');
21 |             $table->integer('user_id')
22 |                 ->unsigned();
23 |             $table->timestamp('created_at')
24 |                 ->nullable();
25 |         }
26 |         );
27 |     }
28 | 
29 | 
30 |     /**
31 |      * Reverse the migrations.
32 |      *
33 |      * @return void
34 |      */
35 |     public function down()
36 |     {
37 |         Schema::dropIfExists('user_tokens');
38 |     }
39 | }
40 | 


--------------------------------------------------------------------------------
/phpunit.xml:
--------------------------------------------------------------------------------
 1 | <?xml version="1.0" encoding="UTF-8"?>
 2 | <phpunit backupGlobals="false"
 3 |          backupStaticAttributes="false"
 4 |          bootstrap="vendor/autoload.php"
 5 |          colors="true"
 6 |          convertErrorsToExceptions="true"
 7 |          convertNoticesToExceptions="true"
 8 |          convertWarningsToExceptions="true"
 9 |          processIsolation="false"
10 |          stopOnFailure="false"
11 |          syntaxCheck="false">
12 |     <testsuites>
13 |         <testsuite name="Package Test Suite">
14 |             <directory suffix=".php">./tests/</directory>
15 |         </testsuite>
16 |     </testsuites>
17 |     <php>
18 |         <env name="APP_KEY" value="AckfSECXIvnK5r28GVIWUAxmbBSjTsmF"/>
19 |     </php>
20 | </phpunit>
21 | 


--------------------------------------------------------------------------------
/src/Exceptions/InvalidTokenException.php:
--------------------------------------------------------------------------------
1 | <?php
2 | 
3 | namespace Whyounes\Passwordless\Exceptions;
4 | 
5 | class InvalidTokenException extends \Exception
6 | {
7 | }
8 | 


--------------------------------------------------------------------------------
/src/Models/Token.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Whyounes\Passwordless\Models;
 4 | 
 5 | use Carbon\Carbon;
 6 | use Illuminate\Database\Eloquent\Model;
 7 | 
 8 | class Token extends Model
 9 | {
10 | 
11 |     protected $table = "user_tokens";
12 | 
13 |     protected $fillable = [
14 |         'token',
15 |         'created_at',
16 |         'user_id',
17 |     ];
18 | 
19 |     protected $dates = ['created_at'];
20 | 
21 |     /**
22 |      * Is not used and not expired.
23 |      *
24 |      * @return bool
25 |      */
26 |     public function isValid()
27 |     {
28 |         return ! $this->isExpired();
29 |     }
30 | 
31 |     /**
32 |      * Is token expired.
33 |      *
34 |      * @return bool
35 |      */
36 |     public function isExpired()
37 |     {
38 |         return $this->created_at
39 |             ->diffInMinutes(Carbon::now()) > (int)config("passwordless.expire_in");
40 |     }
41 | 
42 |     /**
43 |      * Ignore the updated_at column.
44 |      *
45 |      * @param mixed $value Update date
46 |      *
47 |      * @return null
48 |      */
49 |     public function setUpdatedAt($value)
50 |     {
51 |     }
52 | 
53 | 
54 |     /**
55 |      * Token belongs to auth user
56 |      *
57 |      * @return \Illuminate\Database\Eloquent\Relations\BelongsTo
58 |      */
59 |     public function user()
60 |     {
61 |         return $this->belongsTo(config("auth.providers.users.model"));
62 |     }
63 | }
64 | 


--------------------------------------------------------------------------------
/src/Providers/PasswordlessProvider.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Whyounes\Passwordless\Providers;
 4 | 
 5 | use Illuminate\Auth\Events\Authenticated;
 6 | use Illuminate\Support\Facades\Event;
 7 | use Illuminate\Support\ServiceProvider;
 8 | 
 9 | class PasswordlessProvider extends ServiceProvider
10 | {
11 | 
12 |     /**
13 |      * Bootstrap the application services.
14 |      */
15 |     public function boot()
16 |     {
17 |         $this->loadMigrationsFrom(__DIR__.'/../../migrations');
18 |         $this->publishes(
19 |             [
20 |                 __DIR__.'/../../config/passwordless.php' => config_path('passwordless.php'),
21 |                 __DIR__.'/../../lang'                    => resource_path('lang/vendor/passwordless'),
22 |             ]
23 |         );
24 |     }
25 | 
26 |     /**
27 |      * Regsiter application components
28 |      */
29 |     public function register()
30 |     {
31 |         $this->registerEvents();
32 |     }
33 | 
34 |     /**
35 |      * Register application event listeners
36 |      */
37 |     public function registerEvents()
38 |     {
39 |         // Delete user tokens after login
40 |         if (config('passwordless.empty_tokens_after_login') === true) {
41 |             Event::listen(
42 |                 Authenticated::class,
43 |                 function (Authenticated $event) {
44 |                     $event->user->tokens()
45 |                         ->delete();
46 |                 }
47 |             );
48 |         }
49 |     }
50 | }
51 | 


--------------------------------------------------------------------------------
/src/Traits/Passwordless.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | namespace Whyounes\Passwordless\Traits;
 4 | 
 5 | use Whyounes\Passwordless\Exceptions\InvalidTokenException;
 6 | use Whyounes\Passwordless\Models\Token;
 7 | use Illuminate\Support\Facades\App;
 8 | 
 9 | trait Passwordless
10 | {
11 |     /**
12 |      * Validate attributes.
13 |      *
14 |      * @param  string $token Token
15 |      * @throws InvalidTokenException
16 |      */
17 |     public function validateToken($token)
18 |     {
19 |         if (! $this->isValidToken($token)) {
20 |             throw new InvalidTokenException(trans("passwordless.errors.invalid_token"));
21 |         }
22 |     }
23 | 
24 |     /**
25 |      * Validate attributes.
26 |      *
27 |      * @param  string $token Token
28 |      * @return bool
29 |      */
30 |     public function isValidToken($token)
31 |     {
32 |         if (! $token) {
33 |             return false;
34 |         }
35 | 
36 |         /**
37 |          * @var $tokenModel Token
38 |          */
39 |         $tokenModel = $this->tokens()->where('token', $token)->first();
40 | 
41 |         return $tokenModel ? $tokenModel->isValid() : false;
42 |     }
43 | 
44 |     /**
45 |      * Generate a token for the current user.
46 |      *
47 |      * @param bool $save Generate token and save it.
48 |      *
49 |      * @return Token
50 |      */
51 |     public function generateToken($save = false)
52 |     {
53 |         $attributes = [
54 |             'token'      => str_random(16),
55 |             'is_used'    => false,
56 |             'user_id'    => $this->id,
57 |             'created_at' => time()
58 |         ];
59 | 
60 |         $token = App::make(Token::class);
61 |         $token->fill($attributes);
62 |         if ($save) {
63 |             $token->save();
64 |         }
65 | 
66 |         return $token;
67 |     }
68 | 
69 |     /**
70 |      * User tokens relation.
71 |      *
72 |      * @return mixed
73 |      */
74 |     public function tokens()
75 |     {
76 |         return $this->hasMany(Token::class, 'user_id', 'id');
77 |     }
78 | 
79 |     /**
80 |      * Identifier name to be used with token.
81 |      *
82 |      * @return string
83 |      */
84 |     protected function getIdentifierKey()
85 |     {
86 |         return 'email';
87 |     }
88 | }
89 | 


--------------------------------------------------------------------------------
/tests/PasswordlessTraitTest.php:
--------------------------------------------------------------------------------
  1 | <?php
  2 | 
  3 | use Illuminate\Foundation\Testing\Concerns\ImpersonatesUsers;
  4 | use Mockery as m;
  5 | use Orchestra\Testbench\TestCase;
  6 | use Whyounes\Passwordless\Exceptions\InvalidTokenException;
  7 | use Whyounes\Passwordless\Models\Token;
  8 | use Whyounes\Passwordless\Traits\Passwordless;
  9 | 
 10 | class PasswordlessTraitTest extends TestCase
 11 | {
 12 |     use ImpersonatesUsers;
 13 | 
 14 |     private $passwordlessStub;
 15 | 
 16 |     public function setUp()
 17 |     {
 18 |         parent::setUp();
 19 | 
 20 |         \Config::set('passwordless.expire_in', 15);
 21 | 
 22 |         $this->passwordlessStub = new PasswordlessTraitTestStub();
 23 |     }
 24 | 
 25 | 
 26 |     /**
 27 |      * @test
 28 |      * @covers Whyounes\Passwordless\Traits\Passwordless::isValidToken()
 29 |      */
 30 |     public function assert_valid_token()
 31 |     {
 32 |         $this->assertTrue($this->passwordlessStub->isValidToken('token-1'));
 33 |     }
 34 | 
 35 | 
 36 |     /**
 37 |      * @test
 38 |      * @covers Whyounes\Passwordless\Traits\Passwordless::isValidToken()
 39 |      */
 40 |     public function assert_invalid_token()
 41 |     {
 42 |         $this->assertFalse($this->passwordlessStub->isValidToken('token-4'));
 43 |     }
 44 | 
 45 | 
 46 |     /**
 47 |      * @test
 48 |      * @covers Whyounes\Passwordless\Traits\Passwordless::validateToken()
 49 |      */
 50 |     public function assert_throws_exception_on_invalid_token()
 51 |     {
 52 |         $this->expectException(InvalidTokenException::class);
 53 |         $this->passwordlessStub->validateToken('token-4');
 54 |     }
 55 | 
 56 | 
 57 |     /**
 58 |      * @test
 59 |      * @covers Whyounes\Passwordless\Traits\Passwordless::generateToken()
 60 |      */
 61 |     public function assert_it_generates_token()
 62 |     {
 63 |         $token = $this->passwordlessStub->generateToken();
 64 | 
 65 |         $this->assertInstanceOf(Token::class, $token);
 66 |         $this->assertInternalType('string', $token->token);
 67 |     }
 68 | 
 69 | 
 70 |     /**
 71 |      * @test
 72 |      * @runTestsInSeparateProcesses
 73 |      * @preserveGlobalState disabled
 74 |      * @covers              Whyounes\Passwordless\Traits\Passwordless::generateToken()
 75 |      */
 76 |     public function assert_it_generates_token_and_save_it()
 77 |     {
 78 |         $tokenMock = m::mock(Token::class."[save]");
 79 |         $tokenMock->shouldDeferMissing()
 80 |             ->shouldReceive('save')
 81 |             ->once()
 82 |             ->andReturn(true);
 83 |         $this->app->instance(Token::class, $tokenMock);
 84 | 
 85 |         $token = $this->passwordlessStub->generateToken(true);
 86 | 
 87 |         $this->assertInstanceOf(Token::class, $token);
 88 |         $this->assertInternalType('string', $token->token);
 89 |     }
 90 | 
 91 |     /**
 92 |      * @test
 93 |      * @covers Whyounes\Passwordless\Providers\PasswordlessProvider::registerEvents()
 94 |      */
 95 |     public function assert_deletes_tokens_after_auth()
 96 |     {
 97 |         // Please contact me if you have a better way to test this :)
 98 |         // This is called after authentication
 99 |         $this->passwordlessStub->tokens()->delete();
100 |         $this->assertEquals(0, $this->passwordlessStub->tokens->count());
101 |     }
102 | }
103 | 
104 | class PasswordlessTraitTestStub
105 | {
106 | 
107 |     use Passwordless;
108 | 
109 |     public $id;
110 | 
111 |     public $email;
112 | 
113 |     public $tokens;
114 | 
115 |     private $tokensMock;
116 | 
117 | 
118 |     public function __construct()
119 |     {
120 |         $this->id = 1;
121 |         $this->email = 'younes.rafie@gmail.com';
122 |         $this->setTokens();
123 |         $this->setTokensMock();
124 |     }
125 | 
126 | 
127 |     /**
128 |      * Fill user tokens
129 |      */
130 |     private function setTokens()
131 |     {
132 |         $now = Carbon\Carbon::now();
133 |         $this->tokens = collect();
134 | 
135 |         for ($i = 1; $i < 5; $i++) {
136 |             $this->tokens[] = new Token(
137 |                 [
138 |                     'token'      => "token-{$i}",
139 |                     'user_id'    => 1,
140 |                     'created_at' => $now->subMinutes(5 * $i),
141 |                 ]
142 |             );
143 |         }
144 |     }
145 | 
146 | 
147 |     /**
148 |      * Mock querying tokens from DB
149 |      */
150 |     private function setTokensMock()
151 |     {
152 |         $this->tokensMock = m::mock(stdClass::class);
153 | 
154 |         $this->tokensMock->shouldReceive('where')
155 |             ->andReturnUsing(
156 |                 function () {
157 |                     $foundToken = $this->tokens->where('token', func_get_arg(1));
158 | 
159 |                     return $foundToken;
160 |                 }
161 |             );
162 | 
163 |         $this->tokensMock->shouldReceive('delete')
164 |             ->andReturnUsing(function () {
165 |                 $this->tokens = collect();
166 |             });
167 |     }
168 | 
169 | 
170 |     /**
171 |      * Return tokens mock instead of Eloquent relation
172 |      *
173 |      * @return mixed
174 |      */
175 |     public function tokens()
176 |     {
177 |         return $this->tokensMock;
178 |     }
179 | }
180 | 


--------------------------------------------------------------------------------
/tests/TokenTest.php:
--------------------------------------------------------------------------------
 1 | <?php
 2 | 
 3 | use Carbon\Carbon;
 4 | use Mockery as m;
 5 | use Orchestra\Testbench\TestCase;
 6 | use Whyounes\Passwordless\Models\Token;
 7 | 
 8 | class TokenTest extends TestCase
 9 | {
10 | 
11 |     /**
12 |      * @test
13 |      * @covers Whyounes\Passwordless\Models\Token::isValid()
14 |      */
15 |     public function assert_token_is_valid()
16 |     {
17 |         $token = new Token(
18 |             [
19 |                 'token'      => 'token',
20 |                 'created_at' => Carbon::now(),
21 |             ]
22 |         );
23 | 
24 |         $this->assertTrue($token->isValid());
25 |     }
26 | 
27 | 
28 |     /**
29 |      * @test
30 |      * @covers Whyounes\Passwordless\Models\Token::isValid()
31 |      * @covers Whyounes\Passwordless\Models\Token::isExpired()
32 |      */
33 |     public function assert_token_is_invalid()
34 |     {
35 |         $token = new Token(
36 |             [
37 |                 'token'      => 'token',
38 |                 'created_at' => Carbon::now()
39 |                     ->subMinutes(20),
40 |             ]
41 |         );
42 | 
43 |         $this->assertFalse($token->isValid());
44 |         $this->assertTrue($token->isExpired());
45 |     }
46 | }
47 | 


--------------------------------------------------------------------------------