Addition of repository to ease testing and maintainability

tests/Unit/Services/UserServiceTest.php

@@ -26,85 +26,177 @@ namespace Tests\Unit\Services;
 
 use Mockery as m;
 use Tests\TestCase;
-use Pterodactyl\Models\User;
-use Illuminate\Database\Connection;
 use Pterodactyl\Services\UserService;
+use Illuminate\Foundation\Application;
 use Illuminate\Contracts\Hashing\Hasher;
+use Illuminate\Database\ConnectionInterface;
+use Illuminate\Notifications\ChannelManager;
 use Pterodactyl\Notifications\AccountCreated;
 use Pterodactyl\Services\Helpers\TemporaryPasswordService;
+use Pterodactyl\Contracts\Repository\UserRepositoryInterface;
 
 class UserServiceTest extends TestCase
 {
+    /**
+     * @var \Illuminate\Foundation\Application
+     */
+    protected $appMock;
+
+    /**
+     * @var \Illuminate\Database\ConnectionInterface
+     */
     protected $database;
 
+    /**
+     * @var \Illuminate\Contracts\Hashing\Hasher
+     */
     protected $hasher;
 
-    protected $model;
+    /**
+     * @var \Illuminate\Notifications\ChannelManager
+     */
+    protected $notification;
 
+    /**
+     * @var \Pterodactyl\Services\Helpers\TemporaryPasswordService
+     */
     protected $passwordService;
 
+    /**
+     * @var \Pterodactyl\Contracts\Repository\UserRepositoryInterface
+     */
+    protected $repository;
+
+    /**
+     * @var \Pterodactyl\Services\UserService
+     */
     protected $service;
 
+    /**
+     * Setup tests.
+     */
     public function setUp()
     {
         parent::setUp();
 
-        $this->database = m::mock(Connection::class);
+        $this->appMock = m::mock(Application::class);
+        $this->database = m::mock(ConnectionInterface::class);
         $this->hasher = m::mock(Hasher::class);
+        $this->notification = m::mock(ChannelManager::class);
         $this->passwordService = m::mock(TemporaryPasswordService::class);
-        $this->model = m::mock(User::class);
-        $this->app->instance(AccountCreated::class, m::mock(AccountCreated::class));
+        $this->repository = m::mock(UserRepositoryInterface::class);
 
         $this->service = new UserService(
+            $this->appMock,
+            $this->notification,
             $this->database,
             $this->hasher,
             $this->passwordService,
-            $this->model
+            $this->repository
         );
     }
 
-    public function tearDown()
+    /**
+     * Test that a user is created when a password is passed.
+     */
+    public function test_user_creation_with_password()
     {
-        parent::tearDown();
-        m::close();
-    }
+        $user = (object) [
+            'name_first' => 'FirstName',
+            'username' => 'user_name',
+        ];
 
-    public function testCreateFunction()
-    {
-        $data = ['password' => 'password'];
+        $this->hasher->shouldReceive('make')->with('raw-password')->once()->andReturn('enc-password');
+        $this->database->shouldReceive('beginTransaction')->withNoArgs()->once()->andReturnNull();
+        $this->hasher->shouldNotReceive('make');
+        $this->passwordService->shouldNotReceive('generateReset');
+        $this->repository->shouldReceive('create')->with(['password' => 'enc-password'])->once()->andReturn($user);
+        $this->database->shouldReceive('commit')->withNoArgs()->once()->andReturnNull();
+        $this->appMock->shouldReceive('makeWith')->with(AccountCreated::class, [
+            'user' => [
+                'name' => 'FirstName',
+                'username' => 'user_name',
+                'token' => null,
+            ],
+        ])->once()->andReturnNull();
 
-        $this->hasher->shouldReceive('make')->once()->with($data['password'])->andReturn('hashString');
-        $this->database->shouldReceive('transaction')->andReturnNull();
+        $this->notification->shouldReceive('send')->with($user, null)->once()->andReturnNull();
 
-        $this->model->shouldReceive('newInstance')->with(['password' => 'hashString'])->andReturnSelf();
-        $this->model->shouldReceive('save')->andReturn(true);
-        $this->model->shouldReceive('notify')->with(m::type(AccountCreated::class))->andReturnNull();
-        $this->model->shouldReceive('getAttribute')->andReturnSelf();
-
-        $response = $this->service->create($data);
+        $response = $this->service->create([
+            'password' => 'raw-password',
+        ]);
 
         $this->assertNotNull($response);
-        $this->assertInstanceOf(User::class, $response);
+        $this->assertEquals($user->username, $response->username);
+        $this->assertEquals($user->name_first, 'FirstName');
     }
 
-    public function testCreateFunctionWithoutPassword()
+    /**
+     * Test that a user is created with a random password when no password is provided.
+     */
+    public function test_user_creation_without_password()
     {
-        $data = ['email' => 'user@example.com'];
+        $user = (object) [
+            'name_first' => 'FirstName',
+            'username' => 'user_name',
+            'email' => 'user@example.com',
+        ];
 
         $this->hasher->shouldNotReceive('make');
-        $this->model->shouldReceive('newInstance')->with($data)->andReturnSelf();
+        $this->database->shouldReceive('beginTransaction')->withNoArgs()->once()->andReturnNull();
+        $this->hasher->shouldReceive('make')->once()->andReturn('created-enc-password');
+        $this->passwordService->shouldReceive('generateReset')->with('user@example.com')->once()->andReturn('random-token');
 
-        $this->database->shouldReceive('transaction')->andReturn('authToken');
-        $this->hasher->shouldReceive('make')->andReturn('randomString');
-        $this->passwordService->shouldReceive('generateReset')->with($data['email'])->andReturn('authToken');
-        $this->model->shouldReceive('save')->withNoArgs()->andReturn(true);
+        $this->repository->shouldReceive('create')->with([
+            'password' => 'created-enc-password',
+            'email' => 'user@example.com',
+        ])->once()->andReturn($user);
 
-        $this->model->shouldReceive('notify')->with(m::type(AccountCreated::class))->andReturnNull();
-        $this->model->shouldReceive('getAttribute')->andReturnSelf();
+        $this->database->shouldReceive('commit')->withNoArgs()->once()->andReturnNull();
+        $this->appMock->shouldReceive('makeWith')->with(AccountCreated::class, [
+            'user' => [
+                'name' => 'FirstName',
+                'username' => 'user_name',
+                'token' => 'random-token',
+            ],
+        ])->once()->andReturnNull();
 
-        $response = $this->service->create($data);
+        $this->notification->shouldReceive('send')->with($user, null)->once()->andReturnNull();
+
+        $response = $this->service->create([
+            'email' => 'user@example.com',
+        ]);
 
         $this->assertNotNull($response);
-        $this->assertInstanceOf(User::class, $response);
+        $this->assertEquals($user->username, $response->username);
+        $this->assertEquals($user->name_first, 'FirstName');
+        $this->assertEquals($user->email, $response->email);
     }
+
+    /**
+     * Test that passing no password will not attempt any hashing.
+     */
+    public function test_user_update_without_password()
+    {
+        $this->hasher->shouldNotReceive('make');
+        $this->repository->shouldReceive('update')->with(1, ['email' => 'new@example.com'])->once()->andReturnNull();
+
+        $response = $this->service->update(1, ['email' => 'new@example.com']);
+
+        $this->assertNull($response);
+    }
+
+    /**
+     * Test that passing a password will hash it before storage.
+     */
+    public function test_user_update_with_password()
+    {
+        $this->hasher->shouldReceive('make')->with('password')->once()->andReturn('enc-password');
+        $this->repository->shouldReceive('update')->with(1, ['password' => 'enc-password'])->once()->andReturnNull();
+
+        $response = $this->service->update(1, ['password' => 'password']);
+
+        $this->assertNull($response);
+    }
+
 }