Complete Unit, Feature and Api tests

app/Console/Commands/Maintenance/FixUnsplittedAccounts.php

@@ -9,6 +9,9 @@ use Illuminate\Support\Facades\Storage;
 use Illuminate\Support\Facades\Schema;
 use Illuminate\Support\Facades\Log;
 
+/**
+ * @codeCoverageIgnore
+ */
 class FixUnsplittedAccounts extends Command
 {
     /**

app/Group.php

@@ -63,7 +63,9 @@ class Group extends Model
         parent::boot();
 
         static::deleted(function ($model) {
+            // @codeCoverageIgnoreStart
             Log::info(sprintf('Group %s deleted', var_export($model->name, true)));
+            // @codeCoverageIgnoreEnd
         });
     }
 

app/Services/TwoFAccountService.php

@@ -200,17 +200,12 @@ class TwoFAccountService
         // whereIn() expects an array
         $ids = is_array($ids) ? $ids : func_get_args();
 
-        if ($ids) {
-            TwoFAccount::whereIn('id', $ids)
-                        ->update(
-                            ['group_id' => NULL]
-                        );
-            
-            Log::info(sprintf('TwoFAccounts #%s withdrawn', implode(',#', $ids)));
-        }
-        // @codeCoverageIgnoreStart
-        else Log::info('No TwoFAccount to withdraw');
-        // @codeCoverageIgnoreEnd
+        TwoFAccount::whereIn('id', $ids)
+                    ->update(
+                        ['group_id' => NULL]
+                    );
+        
+        Log::info(sprintf('TwoFAccounts #%s withdrawn', implode(',#', $ids)));
     }
 
 
@@ -242,10 +237,14 @@ class TwoFAccountService
      */
     private function commaSeparatedToArray($ids)
     {
-        $regex = "/^\d+(,{1}\d+)*$/";
-        if (preg_match($regex, $ids)) {
-            $ids = explode(',', $ids);
+        if(is_string($ids))
+        {
+            $regex = "/^\d+(,{1}\d+)*$/";
+            if (preg_match($regex, $ids)) {
+                $ids = explode(',', $ids);
+            }
         }
+        
         return $ids;
     }
 
@@ -467,8 +466,10 @@ class TwoFAccountService
                 
             return $newFilename;
         }
+        // @codeCoverageIgnoreStart
         catch (\Assert\AssertionFailedException|\Assert\InvalidArgumentException|\Exception|\Throwable $ex) {
             return null;
         }
+        // @codeCoverageIgnoreEnd
     }
 }

tests/Api/v1/Controllers/Auth/ForgotPasswordControllerTest.php

@@ -81,7 +81,7 @@ class ForgotPasswordControllerTest extends FeatureTestCase
     /**
      * @test
      */
-    public function test_submit_email_password_request__in_demo_mode_returns_unauthorized()
+    public function test_submit_email_password_request_in_demo_mode_returns_unauthorized()
     {
         Config::set('2fauth.config.isDemoApp', true);
 

tests/Api/v1/Controllers/GroupControllerTest.php

@@ -10,6 +10,7 @@ use App\TwoFAccount;
 
 /**
  * @covers \App\Api\v1\Controllers\GroupController
+ * @covers \App\Api\v1\Resources\GroupResource
  */
 class GroupControllerTest extends FeatureTestCase
 {

tests/Api/v1/Controllers/IconControllerTest.php

@@ -4,13 +4,14 @@ namespace Tests\Api\v1\Controllers;
 
 use Illuminate\Http\UploadedFile;
 use Illuminate\Foundation\Testing\WithoutMiddleware;
-use Tests\TestCase;
+use Tests\FeatureTestCase;
 
+use App\TwoFAccount;
 
 /**
  * @covers \App\Api\v1\Controllers\IconController
  */
-class IconControllerTest extends TestCase
+class IconControllerTest extends FeatureTestCase
 {
 
     use WithoutMiddleware;
@@ -52,7 +53,6 @@ class IconControllerTest extends TestCase
     {
         $response = $this->json('DELETE', '/api/v1/icons/testIcon.jpg')
             ->assertNoContent(204);
-
     }
 
 

tests/Api/v1/Controllers/SettingControllerTest.php

@@ -172,7 +172,6 @@ class SettingControllerTest extends FeatureTestCase
     {
         $response = $this->actingAs($this->user, 'api')
             ->json('PUT', '/api/v1/settings/' . self::TWOFAUTH_NATIVE_SETTING, [
-                'key' => self::TWOFAUTH_NATIVE_SETTING,
                 'value' => self::TWOFAUTH_NATIVE_SETTING_CHANGED_VALUE,
             ])
             ->assertOk()
@@ -193,7 +192,6 @@ class SettingControllerTest extends FeatureTestCase
 
         $response = $this->actingAs($this->user, 'api')
             ->json('PUT', '/api/v1/settings/' . self::USER_DEFINED_SETTING, [
-                'key' => self::USER_DEFINED_SETTING,
                 'value' => self::USER_DEFINED_SETTING_CHANGED_VALUE,
             ])
             ->assertOk()
@@ -211,7 +209,6 @@ class SettingControllerTest extends FeatureTestCase
     {
         $response = $this->actingAs($this->user, 'api')
             ->json('PUT', '/api/v1/settings/' . self::USER_DEFINED_SETTING, [
-                'key' => self::USER_DEFINED_SETTING,
                 'value' => self::USER_DEFINED_SETTING_CHANGED_VALUE,
             ])
             ->assertOk()

tests/Api/v1/Controllers/TwoFAccountControllerTest.php

@@ -1,6 +1,6 @@
 <?php
 
-namespace Tests\Api\v1\Unit;
+namespace Tests\Api\v1\Controllers;
 
 use App\User;
 use App\Group;
@@ -12,6 +12,8 @@ use Illuminate\Support\Facades\Storage;
 
 /**
  * @covers \App\Api\v1\Controllers\TwoFAccountController
+ * @covers \App\Api\v1\Resources\TwoFAccountReadResource
+ * @covers \App\Api\v1\Resources\TwoFAccountStoreResource
  */
 class TwoFAccountControllerTest extends FeatureTestCase
 {
@@ -235,27 +237,27 @@ class TwoFAccountControllerTest extends FeatureTestCase
     /**
      * @test
      */
-    public function test_show_twofaccount_with_indeciphered_data_returns_replaced_data()
-    {
-        $dbEncryptionService = resolve('App\Services\DbEncryptionService');
-        $dbEncryptionService->setTo(true);
+    // public function test_show_twofaccount_with_indeciphered_data_returns_replaced_data()
+    // {
+    //     $dbEncryptionService = resolve('App\Services\DbEncryptionService');
+    //     $dbEncryptionService->setTo(true);
 
-        $twofaccount = factory(TwoFAccount::class)->create();
+    //     $twofaccount = factory(TwoFAccount::class)->create();
 
-        DB::table('twofaccounts')
-            ->where('id', $twofaccount->id)
-            ->update([
-                'secret' => '**encrypted**',
-                'account' => '**encrypted**',
-            ]);
+    //     DB::table('twofaccounts')
+    //         ->where('id', $twofaccount->id)
+    //         ->update([
+    //             'secret' => '**encrypted**',
+    //             'account' => '**encrypted**',
+    //         ]);
 
-        $response = $this->actingAs($this->user, 'api')
-            ->json('GET', '/api/v1/twofaccounts/' . $twofaccount->id)
-            ->assertJsonFragment([
-                'secret' => '*indecipherable*',
-                'account' => '*indecipherable*',
-            ]);
-    }
+    //     $response = $this->actingAs($this->user, 'api')
+    //         ->json('GET', '/api/v1/twofaccounts/' . $twofaccount->id)
+    //         ->assertJsonFragment([
+    //             'secret' => '*indecipherable*',
+    //             'account' => '*indecipherable*',
+    //         ]);
+    // }
 
 
     /**
@@ -784,8 +786,8 @@ class TwoFAccountControllerTest extends FeatureTestCase
      */
     public function test_get_otp_using_indecipherable_twofaccount_id_returns_bad_request()
     {
-        $dbEncryptionService = resolve('App\Services\DbEncryptionService');
-        $dbEncryptionService->setTo(true);
+        $settingService = resolve('App\Services\SettingServiceInterface');
+        $settingService->set('useEncryption', true);
 
         $twofaccount = factory(TwoFAccount::class)->create();
 

tests/Api/v1/Requests/TwoFAccountDynamicRequestTest.php

@@ -0,0 +1,55 @@
+<?php
+
+namespace Tests\Api\v1\Requests;
+
+use App\Api\v1\Requests\TwoFAccountDynamicRequest;
+use App\Api\v1\Requests\TwoFAccountUriRequest;
+use App\Api\v1\Requests\TwoFAccountStoreRequest;
+use Illuminate\Foundation\Testing\WithoutMiddleware;
+use Illuminate\Support\Facades\Validator;
+use Illuminate\Support\Facades\Auth;
+use Tests\TestCase;
+
+class TwoFAccountDynamicRequestTest extends TestCase
+{
+
+    use WithoutMiddleware;
+
+    /**
+     * @test
+     */
+    public function test_user_is_authorized()
+    {   
+        Auth::shouldReceive('check')
+        ->once()
+        ->andReturn(true);
+
+        $request = new TwoFAccountDynamicRequest();
+    
+        $this->assertTrue($request->authorize());
+    }
+
+    /**
+     * @test
+     */
+    public function test_returns_TwoFAccountUriRequest_rules_when_has_uri_input()
+    {
+        $twofaccountUriRequest = new TwoFAccountUriRequest();
+        $request = new TwoFAccountDynamicRequest();
+        $request->merge(['uri' => 'uristring']);
+
+        $this->assertEquals($twofaccountUriRequest->rules(), $request->rules());
+    }
+
+    /**
+     * @test
+     */
+    public function test_returns_TwoFAccountStoreRequest_rules_otherwise()
+    {
+        $twofaccountStoreRequest = new TwoFAccountStoreRequest();
+        $request = new TwoFAccountDynamicRequest();
+
+        $this->assertEquals($twofaccountStoreRequest->rules(), $request->rules());
+    }
+
+}

tests/Feature/Console/CheckDbConnectionTest.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace Tests\Feature\Console;
+
+use App\User;
+use Tests\FeatureTestCase;
+use Illuminate\Support\Facades\Config;
+use Illuminate\Support\Facades\DB;
+
+
+/**
+ * @covers \App\Console\Commands\CheckDbConnection
+ */
+class CheckDbConnectionTest extends FeatureTestCase
+{
+
+    /**
+     * @test
+     */
+    public function test_CheckDbConnection_ends_successfully()
+    {
+        $this->artisan('2fauth:check-db-connection')
+            ->expectsOutput('This will return the name of the connected database, otherwise false')
+            ->expectsOutput(DB::connection()->getDatabaseName())
+            ->assertExitCode(1);
+    }
+
+    /**
+     * @test
+     */
+    public function test_CheckDbConnection_without_db_returns_false()
+    {
+        DB::shouldReceive('connection', 'getPDO')
+            ->andThrow(new \Exception());
+
+        $this->artisan('2fauth:check-db-connection')          
+            ->assertExitCode(0);
+    }
+}

tests/Feature/ConsoleTest.php → tests/Feature/Console/ResetDemoTest.php

@@ -1,13 +1,13 @@
 <?php
 
-namespace Tests\Feature;
+namespace Tests\Feature\Console;
 
 use App\User;
 use Tests\FeatureTestCase;
 use Illuminate\Support\Facades\Config;
 use Illuminate\Support\Facades\DB;
 
-class ConsoleTest extends FeatureTestCase
+class ResetDemoTest extends FeatureTestCase
 {
 
     /**

tests/Feature/Http/Requests/LoginRequestTest.php

@@ -0,0 +1,109 @@
+<?php
+
+namespace Tests\Api\v1\Requests;
+
+use App\Http\Requests\LoginRequest;
+use Illuminate\Foundation\Testing\WithoutMiddleware;
+use Illuminate\Support\Facades\Auth;
+use Illuminate\Support\Facades\Validator;
+use Tests\FeatureTestCase;
+
+
+/**
+ * @covers \App\Http\Requests\LoginRequest
+ */
+class LoginRequestTest extends FeatureTestCase
+{
+
+    use WithoutMiddleware;
+
+    /**
+     * @test
+     */
+    public function test_user_is_authorized()
+    {
+        $request = new LoginRequest();
+    
+        $this->assertTrue($request->authorize());
+    }
+
+
+    /**
+     * @dataProvider provideValidData
+     */
+    public function test_valid_data(array $data) : void
+    {
+        factory(\App\User::class)->create([
+            'email' => 'JOHN.DOE@example.com'
+        ]);
+
+        $request = new LoginRequest();
+        $validator = Validator::make($data, $request->rules());
+
+        $this->assertFalse($validator->fails());
+    }
+
+
+    /**
+     * Provide Valid data for validation test
+     */
+    public function provideValidData() : array
+    {
+        return [
+            [[
+                'email'     => 'john.doe@example.com',
+                'password'  => 'MyPassword'
+            ]],
+            [[
+                'email'     => 'JOHN.doe@example.com',
+                'password'  => 'MyPassword'
+            ]],
+        ];
+    }
+
+
+    /**
+     * @dataProvider provideInvalidData
+     */
+    public function test_invalid_data(array $data) : void
+    {      
+        factory(\App\User::class)->create([
+            'email' => 'JOHN.DOE@example.com'
+        ]);
+
+        $request = new LoginRequest();
+        $validator = Validator::make($data, $request->rules());
+
+        $this->assertTrue($validator->fails());
+    }
+
+
+    /**
+     * Provide invalid data for validation test
+     */
+    public function provideInvalidData() : array
+    {
+        return [
+            [[
+                'email'     => '', // required
+                'password'  => 'MyPassword',
+            ]],
+            [[
+                'email'     => 'john', // email
+                'password'  => 'MyPassword',
+            ]],
+            [[
+                'email'     => 'john@example.com', // exists
+                'password'  => 'MyPassword',
+            ]],
+            [[
+                'email'     => 'john.doe@example.com',
+                'password'  => '', // required
+            ]],
+            [[
+                'email'     => 'john.doe@example.com',
+                'password'  => true, // string
+            ]],
+        ];
+    }
+}

tests/Feature/Services/GroupServiceTest.php

@@ -0,0 +1,310 @@
+<?php
+
+namespace Tests\Feature\Services;
+
+use App\Group;
+use App\TwoFAccount;
+use Tests\FeatureTestCase;
+use Tests\Classes\LocalFile;
+use Illuminate\Support\Facades\DB;
+
+
+/**
+ * @covers \App\Services\GroupService
+ */
+class GroupServiceTest extends FeatureTestCase
+{
+    /**
+     * App\Services\QrCodeService $groupService
+     */
+    protected $groupService;
+
+
+    /**
+     * App\Services\SettingServiceInterface $settingService
+     */
+    protected $settingService;
+
+
+    /**
+     * App\Group $groupOne, $groupTwo
+     */
+    protected $groupOne, $groupTwo;
+
+
+    /**
+     * App\Group $twofaccountOne, $twofaccountTwo
+     */
+    protected $twofaccountOne, $twofaccountTwo;
+
+    private const NEW_GROUP_NAME = 'MyNewGroup';
+    private const TWOFACCOUNT_COUNT = 2;
+    private const ACCOUNT = 'account';
+    private const SERVICE = 'service';
+    private const SECRET = 'A4GRFHVVRBGY7UIW';
+    private const ALGORITHM_CUSTOM = 'sha256';
+    private const DIGITS_CUSTOM = 7;
+    private const PERIOD_CUSTOM = 40;
+    private const IMAGE = 'https%3A%2F%2Fen.opensuse.org%2Fimages%2F4%2F44%2FButton-filled-colour.png';
+    private const ICON = 'test.png';
+    private const TOTP_FULL_CUSTOM_URI = 'otpauth://totp/'.self::SERVICE.':'.self::ACCOUNT.'?secret='.self::SECRET.'&issuer='.self::SERVICE.'&digits='.self::DIGITS_CUSTOM.'&period='.self::PERIOD_CUSTOM.'&algorithm='.self::ALGORITHM_CUSTOM.'&image='.self::IMAGE;
+
+
+
+    /**
+     * @test
+     */
+    public function setUp() : void
+    {
+        parent::setUp();
+
+        $this->groupService = $this->app->make('App\Services\GroupService');
+        $this->settingService = $this->app->make('App\Services\SettingServiceInterface');
+
+        $this->groupOne = new Group;
+        $this->groupOne->name = 'MyGroupOne';
+        $this->groupOne->save();
+
+        $this->groupTwo = new Group;
+        $this->groupTwo->name = 'MyGroupTwo';
+        $this->groupTwo->save();
+
+        $this->twofaccountOne = new TwoFAccount;
+        $this->twofaccountOne->legacy_uri = self::TOTP_FULL_CUSTOM_URI;
+        $this->twofaccountOne->service = self::SERVICE;
+        $this->twofaccountOne->account = self::ACCOUNT;
+        $this->twofaccountOne->icon = self::ICON;
+        $this->twofaccountOne->otp_type = 'totp';
+        $this->twofaccountOne->secret = self::SECRET;
+        $this->twofaccountOne->digits = self::DIGITS_CUSTOM;
+        $this->twofaccountOne->algorithm = self::ALGORITHM_CUSTOM;
+        $this->twofaccountOne->period = self::PERIOD_CUSTOM;
+        $this->twofaccountOne->counter = null;
+        $this->twofaccountOne->save();
+
+        $this->twofaccountTwo = new TwoFAccount;
+        $this->twofaccountTwo->legacy_uri = self::TOTP_FULL_CUSTOM_URI;
+        $this->twofaccountTwo->service = self::SERVICE;
+        $this->twofaccountTwo->account = self::ACCOUNT;
+        $this->twofaccountTwo->icon = self::ICON;
+        $this->twofaccountTwo->otp_type = 'totp';
+        $this->twofaccountTwo->secret = self::SECRET;
+        $this->twofaccountTwo->digits = self::DIGITS_CUSTOM;
+        $this->twofaccountTwo->algorithm = self::ALGORITHM_CUSTOM;
+        $this->twofaccountTwo->period = self::PERIOD_CUSTOM;
+        $this->twofaccountTwo->counter = null;
+        $this->twofaccountTwo->save();
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_getAll_returns_a_collection()
+    {
+        $this->assertInstanceOf(\Illuminate\Database\Eloquent\Collection::class, $this->groupService->getAll());
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_getAll_adds_pseudo_group_on_top_of_user_groups()
+    {
+        $groups = $this->groupService->getAll();
+        
+        $this->assertEquals(0, $groups->first()->id);
+        $this->assertEquals(__('commons.all'), $groups->first()->name);
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_getAll_returns_pseudo_group_with_all_twofaccounts_count()
+    {
+        $groups = $this->groupService->getAll();
+        
+        $this->assertEquals(self::TWOFACCOUNT_COUNT, $groups->first()->twofaccounts_count);
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_create_persists_and_returns_created_group()
+    {
+        $newGroup = $this->groupService->create(['name' => self::NEW_GROUP_NAME]);
+        
+        $this->assertDatabaseHas('groups', ['name' => self::NEW_GROUP_NAME]);
+        $this->assertInstanceOf(\App\Group::class, $newGroup);
+        $this->assertEquals(self::NEW_GROUP_NAME, $newGroup->name);
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_update_persists_and_returns_updated_group()
+    {
+        $this->groupOne = $this->groupService->update($this->groupOne, ['name' => self::NEW_GROUP_NAME]);
+        
+        $this->assertDatabaseHas('groups', ['name' => self::NEW_GROUP_NAME]);
+        $this->assertInstanceOf(\App\Group::class, $this->groupOne);
+        $this->assertEquals(self::NEW_GROUP_NAME, $this->groupOne->name);
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_delete_a_groupId_clear_db_and_returns_deleted_count()
+    {
+        $deleted = $this->groupService->delete($this->groupOne->id);
+        
+        $this->assertDatabaseMissing('groups', ['id' => $this->groupOne->id]);
+        $this->assertEquals(1, $deleted);
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_delete_an_array_of_ids_clear_db_and_returns_deleted_count()
+    {
+        $deleted = $this->groupService->delete([$this->groupOne->id, $this->groupTwo->id]);
+        
+        $this->assertDatabaseMissing('groups', ['id' => $this->groupOne->id]);
+        $this->assertDatabaseMissing('groups', ['id' => $this->groupTwo->id]);
+        $this->assertEquals(2, $deleted);
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_delete_default_group_reset_defaultGroup_setting()
+    {
+        $this->settingService->set('defaultGroup', $this->groupOne->id);
+
+        $deleted = $this->groupService->delete($this->groupOne->id);
+        
+        $this->assertDatabaseHas('options', [
+            'key' => 'defaultGroup',
+            'value' => 0
+        ]);
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_delete_active_group_reset_activeGroup_setting()
+    {
+        $this->settingService->set('rememberActiveGroup', true);
+        $this->settingService->set('activeGroup', $this->groupOne->id);
+        
+        $deleted = $this->groupService->delete($this->groupOne->id);
+        
+        $this->assertDatabaseHas('options', [
+            'key' => 'activeGroup',
+            'value' => 0
+        ]);
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_assign_a_twofaccountid_to_a_specified_group_persists_the_relation()
+    {
+        
+        $this->groupService->assign($this->twofaccountOne->id, $this->groupOne);
+        
+        $this->assertDatabaseHas('twofaccounts', [
+            'id' => $this->twofaccountOne->id,
+            'group_id' => $this->groupOne->id,
+        ]);
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_assign_multiple_twofaccountid_to_a_specified_group_persists_the_relation()
+    {
+        $this->groupService->assign([$this->twofaccountOne->id, $this->twofaccountTwo->id], $this->groupOne);
+        
+        $this->assertDatabaseHas('twofaccounts', [
+            'id' => $this->twofaccountOne->id,
+            'group_id' => $this->groupOne->id,
+        ]);
+        $this->assertDatabaseHas('twofaccounts', [
+            'id' => $this->twofaccountTwo->id,
+            'group_id' => $this->groupOne->id,
+        ]);
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_assign_a_twofaccountid_to_no_group_assigns_to_default_group()
+    {
+        $this->settingService->set('defaultGroup', $this->groupTwo->id);
+        
+        $this->groupService->assign($this->twofaccountOne->id);
+        
+        $this->assertDatabaseHas('twofaccounts', [
+            'id' => $this->twofaccountOne->id,
+            'group_id' => $this->groupTwo->id,
+        ]);
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_assign_a_twofaccountid_to_no_group_assigns_to_active_group()
+    {
+        $this->settingService->set('defaultGroup', -1);
+        $this->settingService->set('activeGroup', $this->groupTwo->id);
+        
+        $this->groupService->assign($this->twofaccountOne->id);
+        
+        $this->assertDatabaseHas('twofaccounts', [
+            'id' => $this->twofaccountOne->id,
+            'group_id' => $this->groupTwo->id,
+        ]);
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_assign_a_twofaccountid_to_missing_active_group_does_not_fails()
+    {
+        $this->settingService->set('defaultGroup', -1);
+        $this->settingService->set('activeGroup', 100000);
+        
+        $this->groupService->assign($this->twofaccountOne->id);
+        
+        $this->assertDatabaseHas('twofaccounts', [
+            'id' => $this->twofaccountOne->id,
+            'group_id' => null,
+        ]);
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_getAccounts_returns_accounts()
+    {
+        $this->groupService->assign([$this->twofaccountOne->id, $this->twofaccountTwo->id], $this->groupOne);
+        $accounts = $this->groupService->getAccounts($this->groupOne);
+        
+        $this->assertEquals(2, $accounts->count());
+    }
+
+}

tests/Feature/Services/QrCodeServiceTest.php

@@ -0,0 +1,67 @@
+<?php
+
+namespace Tests\Feature\Services;
+
+use Tests\FeatureTestCase;
+use Tests\Classes\LocalFile;
+use Illuminate\Support\Facades\DB;
+
+
+/**
+ * @covers \App\Services\QrCodeService
+ */
+class QrCodeServiceTest extends FeatureTestCase
+{
+    /**
+     * App\Services\QrCodeService $qrcodeService
+     */
+    protected $qrcodeService;
+
+    private const STRING_TO_ENCODE = 'stringToEncode';
+    private const STRING_ENCODED = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAMgAAADICAIAAAAiOjnJAAAABnRSTlMA/wD/AP83WBt9AAAACXBIWXMAAA7EAAAOxAGVKw4bAAADOklEQVR4nO3dMW7kMBAAwdPh/v/ldeBLFRCYBkm7KveaEBoMBhT1fD6fPzDt7+4F8DMJi4SwSAiLhLBICIuEsEgIi4SwSAiLhLBICIuEsEgIi4SwSPxb/YPneYp1jHs7Z7a6/tXzam+/P7WeXVafgx2LhLBICIuEsEgIi4SwSAiLxPIc682u9xOn5lKnzZNueZ5v7FgkhEVCWCSERUJYJIRFQlgkxuZYb6bmIlNznanzUrfPmer127FICIuEsEgIi4SwSAiLhLBI5HOs290y3zqNHYuEsEgIi4SwSAiLhLBICIuEOdZ/p71XeDs7FglhkRAWCWGREBYJYZEQFol8jnXa+aTT1rPqlvXbsUgIi4SwSAiLhLBICIuEsEiMzbFuOc9U34819b7hLc/zjR2LhLBICIuEsEgIi4SwSAiLxHPL+Z7a1HcP+WbHIiEsEsIiISwSwiIhLBLCIrE8x6rPCU2tpz5f9eaWc1r1Ou1YJIRFQlgkhEVCWCSERUJYJPLzWKd912/Xuavb3xM0x+IIwiIhLBLCIiEsEsIiISwSy/dj7ZpL1fOn+nxS/X/rc2ar7FgkhEVCWCSERUJYJIRFQlgk8u8VrjrtPb4p9VxtVf37diwSwiIhLBLCIiEsEsIiISwS+f1Yu+6dmlKvf8ppczs7FglhkRAWCWGREBYJYZEQFolf973C0+5bX7XrPcRVdiwSwiIhLBLCIiEsEsIiISwSx32vcMqu+9lP+7+7zmnZsUgIi4SwSAiLhLBICIuEsEiM3Y91y/cH699Z/f2357Y6l6qfg+8VcgRhkRAWCWGREBYJYZEQFon8nvf6XvJd6vNP9fcHvVfIlYRFQlgkhEVCWCSERUJYJI77XmHttPvQp9az6x78N3YsEsIiISwSwiIhLBLCIiEsEr9ujjXltHvCTvt+oh2LhLBICIuEsEgIi4SwSAiLRD7HOu19wDf1veqn3V9V/74di4SwSAiLhLBICIuEsEgIi8TYHOu080mrpt7LO+3+qqn75VfZsUgIi4SwSAiLhLBICIuEsEg8t5yX4i52LBLCIiEsEsIiISwSwiIhLBLCIiEsEsIiISwSwiIhLBLCIiEsEl+BmgChoSs9XAAAAABJRU5ErkJggg==';
+    private const DECODED_IMAGE = 'otpauth://totp/test@test.com?secret=A4GRFHVIRBGY7UIW';
+
+    
+    /**
+     * @test
+     */
+    public function setUp() : void
+    {
+        parent::setUp();
+
+        $this->qrcodeService = $this->app->make('App\Services\QrCodeService');
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_encode_returns_correct_value()
+    {
+        // $rendered = $this->qrcodeService->encode(self::STRING_TO_ENCODE);
+        $this->assertEquals(self::STRING_ENCODED, $this->qrcodeService->encode(self::STRING_TO_ENCODE));
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_decode_valid_image_returns_correct_value()
+    {
+        $file = LocalFile::fake()->validQrcode();
+
+        $this->assertEquals(self::DECODED_IMAGE, $this->qrcodeService->decode($file));
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_decode_invalid_image_returns_correct_value()
+    {
+        $this->expectException(\App\Exceptions\InvalidQrCodeException::class);
+
+        $this->qrcodeService->decode(LocalFile::fake()->invalidQrcode());
+    }
+
+}

tests/Feature/Services/AppstractOptionsServiceTest.php → tests/Feature/Services/SettingServiceTest.php

@@ -1,17 +1,29 @@
 <?php
 
-namespace Tests\Feature;
+namespace Tests\Feature\Services;
 
 use Tests\FeatureTestCase;
+use Illuminate\Support\Facades\Crypt;
 use Illuminate\Support\Facades\DB;
+use App\TwoFAccount;
 
-class AppstractOptionsServiceTest extends FeatureTestCase
+
+/**
+ * @covers \App\Services\AppstractOptionsService
+ */
+class SettingServiceTest extends FeatureTestCase
 {
     /**
      * App\Services\SettingServiceInterface $settingService
      */
     protected $settingService;
 
+
+    /**
+     * App\Group $groupOne, $groupTwo
+     */
+    protected $twofaccountOne, $twofaccountTwo;
+
     private const KEY = 'key';
     private const VALUE = 'value';
     private const SETTING_NAME = 'MySetting';
@@ -21,6 +33,15 @@ class AppstractOptionsServiceTest extends FeatureTestCase
     private const SETTING_VALUE_FALSE_TRANSFORMED = '{{}}';
     private const SETTING_VALUE_INT = 10;
 
+    private const ACCOUNT = 'account';
+    private const SERVICE = 'service';
+    private const SECRET = 'A4GRFHVVRBGY7UIW';
+    private const ALGORITHM_CUSTOM = 'sha256';
+    private const DIGITS_CUSTOM = 7;
+    private const PERIOD_CUSTOM = 40;
+    private const IMAGE = 'https%3A%2F%2Fen.opensuse.org%2Fimages%2F4%2F44%2FButton-filled-colour.png';
+    private const ICON = 'test.png';
+    private const TOTP_FULL_CUSTOM_URI = 'otpauth://totp/'.self::SERVICE.':'.self::ACCOUNT.'?secret='.self::SECRET.'&issuer='.self::SERVICE.'&digits='.self::DIGITS_CUSTOM.'&period='.self::PERIOD_CUSTOM.'&algorithm='.self::ALGORITHM_CUSTOM.'&image='.self::IMAGE;
 
     /**
      * @test
@@ -30,6 +51,32 @@ class AppstractOptionsServiceTest extends FeatureTestCase
         parent::setUp();
 
         $this->settingService = $this->app->make('App\Services\SettingServiceInterface');
+
+        $this->twofaccountOne = new TwoFAccount;
+        $this->twofaccountOne->legacy_uri = self::TOTP_FULL_CUSTOM_URI;
+        $this->twofaccountOne->service = self::SERVICE;
+        $this->twofaccountOne->account = self::ACCOUNT;
+        $this->twofaccountOne->icon = self::ICON;
+        $this->twofaccountOne->otp_type = 'totp';
+        $this->twofaccountOne->secret = self::SECRET;
+        $this->twofaccountOne->digits = self::DIGITS_CUSTOM;
+        $this->twofaccountOne->algorithm = self::ALGORITHM_CUSTOM;
+        $this->twofaccountOne->period = self::PERIOD_CUSTOM;
+        $this->twofaccountOne->counter = null;
+        $this->twofaccountOne->save();
+
+        $this->twofaccountTwo = new TwoFAccount;
+        $this->twofaccountTwo->legacy_uri = self::TOTP_FULL_CUSTOM_URI;
+        $this->twofaccountTwo->service = self::SERVICE;
+        $this->twofaccountTwo->account = self::ACCOUNT;
+        $this->twofaccountTwo->icon = self::ICON;
+        $this->twofaccountTwo->otp_type = 'totp';
+        $this->twofaccountTwo->secret = self::SECRET;
+        $this->twofaccountTwo->digits = self::DIGITS_CUSTOM;
+        $this->twofaccountTwo->algorithm = self::ALGORITHM_CUSTOM;
+        $this->twofaccountTwo->period = self::PERIOD_CUSTOM;
+        $this->twofaccountTwo->counter = null;
+        $this->twofaccountTwo->save();
     }
 
 
@@ -126,6 +173,98 @@ class AppstractOptionsServiceTest extends FeatureTestCase
             self::VALUE => self::SETTING_VALUE_STRING
         ]);
     }
+    
+
+    /**
+     * @test
+     */
+    public function test_set_useEncryption_on_encrypts_all_accounts()
+    {
+        $this->settingService->set('useEncryption', true);
+
+        $twofaccounts = DB::table('twofaccounts')->get();
+
+        $twofaccounts->each(function ($item, $key) {
+            $this->assertEquals(self::ACCOUNT, Crypt::decryptString($item->account));
+            $this->assertEquals(self::SECRET, Crypt::decryptString($item->secret));
+            $this->assertEquals(self::TOTP_FULL_CUSTOM_URI, Crypt::decryptString($item->legacy_uri));
+        });
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_set_useEncryption_on_twice_prevents_successive_encryption()
+    {
+        $this->settingService->set('useEncryption', true);
+        $this->settingService->set('useEncryption', true);
+
+        $twofaccounts = DB::table('twofaccounts')->get();
+
+        $twofaccounts->each(function ($item, $key) {
+            $this->assertEquals(self::ACCOUNT, Crypt::decryptString($item->account));
+            $this->assertEquals(self::SECRET, Crypt::decryptString($item->secret));
+            $this->assertEquals(self::TOTP_FULL_CUSTOM_URI, Crypt::decryptString($item->legacy_uri));
+        });
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_set_useEncryption_off_decrypts_all_accounts()
+    {
+        $this->settingService->set('useEncryption', true);
+        $this->settingService->set('useEncryption', false);
+
+        $twofaccounts = DB::table('twofaccounts')->get();
+
+        $twofaccounts->each(function ($item, $key) {
+            $this->assertEquals(self::ACCOUNT, $item->account);
+            $this->assertEquals(self::SECRET, $item->secret);
+            $this->assertEquals(self::TOTP_FULL_CUSTOM_URI, $item->legacy_uri);
+        });
+    }
+
+
+    /**
+     * @test
+     * @dataProvider provideUndecipherableData
+     */
+    public function test_set_useEncryption_off_returns_exception_when_data_are_undecipherable(array $data)
+    {
+        $this->expectException(\App\Exceptions\DbEncryptionException::class);
+
+        $this->settingService->set('useEncryption', true);
+
+        $affected = DB::table('twofaccounts')
+            ->where('id', $this->twofaccountOne->id)
+            ->update($data);
+
+            $this->settingService->set('useEncryption', false);
+
+        $twofaccount = TwoFAccount::find($this->twofaccountOne->id);
+    }
+
+
+    /**
+     * Provide invalid data for validation test
+     */
+    public function provideUndecipherableData() : array
+    {
+        return [
+            [[
+                'account' => 'undecipherableString'
+            ]],
+            [[
+                'secret' => 'undecipherableString'
+            ]],
+            [[
+                'legacy_uri' => 'undecipherableString'
+            ]],
+        ];
+    }
 
 
     /**

tests/Feature/Services/TwoFAccountServiceTest.php

@@ -1,7 +1,8 @@
 <?php
 
-namespace Tests\Feature;
+namespace Tests\Feature\Services;
 
+use App\Group;
 use App\TwoFAccount;
 use Tests\FeatureTestCase;
 use Illuminate\Support\Facades\DB;
@@ -24,6 +25,12 @@ class TwoFAccountServiceTest extends FeatureTestCase
     protected $customTotpTwofaccount;
 
 
+    /**
+     * App\Group $group
+     */
+    protected $group;
+
+
     /**
      * App\TwoFAccount $customTotpTwofaccount
      */
@@ -126,6 +133,11 @@ class TwoFAccountServiceTest extends FeatureTestCase
         $this->customHotpTwofaccount->period = null;
         $this->customHotpTwofaccount->counter = self::COUNTER_CUSTOM;
         $this->customHotpTwofaccount->save();
+
+
+        $this->group = new Group;
+        $this->group->name = 'MyGroup';
+        $this->group->save();
     }
 
 
@@ -532,6 +544,20 @@ class TwoFAccountServiceTest extends FeatureTestCase
     }
 
 
+    /**
+     * @test
+     */
+    public function test_getOTP_for_totp_with_undecipherable_secret_returns_UndecipherableException()
+    {
+        $this->expectException(\App\Exceptions\UndecipherableException::class);
+        $otp_from_uri = $this->twofaccountService->getOTP([
+            'account'   => self::ACCOUNT,
+            'otp_type'  => 'totp',
+            'secret'    => __('errors.indecipherable'),
+        ]);
+    }
+
+
     /**
      * @test
      */
@@ -618,4 +644,119 @@ class TwoFAccountServiceTest extends FeatureTestCase
         $this->assertStringContainsString('secret='.self::SECRET, $uri);
     }
 
+
+    /**
+     * @test
+     */
+    public function test_withdraw_comma_separated_ids_deletes_relation()
+    {
+        $twofaccounts = collect([$this->customHotpTwofaccount, $this->customTotpTwofaccount]);
+        $this->group->twofaccounts()->saveMany($twofaccounts);
+        
+        $this->twofaccountService->withdraw($this->customHotpTwofaccount->id.','.$this->customTotpTwofaccount->id);
+
+        $this->assertDatabaseHas('twofaccounts', [
+            'id'      => $this->customTotpTwofaccount->id,
+            'group_id'      => null,
+        ]);
+
+        $this->assertDatabaseHas('twofaccounts', [
+            'id'      => $this->customHotpTwofaccount->id,
+            'group_id'      => null,
+        ]);
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_withdraw_array_of_model_ids_deletes_relation()
+    {
+        $twofaccounts = collect([$this->customHotpTwofaccount, $this->customTotpTwofaccount]);
+        $this->group->twofaccounts()->saveMany($twofaccounts);
+        
+        $this->twofaccountService->withdraw([$this->customHotpTwofaccount->id, $this->customTotpTwofaccount->id]);
+
+        $this->assertDatabaseHas('twofaccounts', [
+            'id'      => $this->customTotpTwofaccount->id,
+            'group_id'      => null,
+        ]);
+
+        $this->assertDatabaseHas('twofaccounts', [
+            'id'      => $this->customHotpTwofaccount->id,
+            'group_id'      => null,
+        ]);
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_withdraw_single_id_deletes_relation()
+    {
+        $twofaccounts = collect([$this->customHotpTwofaccount, $this->customTotpTwofaccount]);
+        $this->group->twofaccounts()->saveMany($twofaccounts);
+        
+        $this->twofaccountService->withdraw($this->customTotpTwofaccount->id);
+
+        $this->assertDatabaseHas('twofaccounts', [
+            'id'      => $this->customTotpTwofaccount->id,
+            'group_id'      => null,
+        ]);
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_withdraw_missing_ids_returns_void()
+    {
+        $this->assertNull($this->twofaccountService->withdraw(null));
+    }
+
+    
+    /**
+     * @test
+     */
+    public function test_delete_comma_separated_ids()
+    {        
+        $this->twofaccountService->delete($this->customHotpTwofaccount->id.','.$this->customTotpTwofaccount->id);
+
+        $this->assertDatabaseMissing('twofaccounts', [
+            'id'      => $this->customTotpTwofaccount->id,
+        ]);
+        $this->assertDatabaseMissing('twofaccounts', [
+            'id'      => $this->customHotpTwofaccount->id,
+        ]);
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_delete_array_of_ids()
+    {        
+        $this->twofaccountService->delete([$this->customTotpTwofaccount->id, $this->customHotpTwofaccount->id]);
+
+        $this->assertDatabaseMissing('twofaccounts', [
+            'id'      => $this->customTotpTwofaccount->id,
+        ]);
+        $this->assertDatabaseMissing('twofaccounts', [
+            'id'      => $this->customHotpTwofaccount->id,
+        ]);
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_delete_single_id()
+    {        
+        $this->twofaccountService->delete($this->customTotpTwofaccount->id);
+
+        $this->assertDatabaseMissing('twofaccounts', [
+            'id'      => $this->customTotpTwofaccount->id,
+        ]);
+    }
+
 }

tests/ModelTestCase.php

@@ -0,0 +1,138 @@
+<?php
+
+namespace Tests;
+
+use Illuminate\Database\Eloquent\Model;
+use Illuminate\Database\Eloquent\Collection;
+use Illuminate\Database\Eloquent\Relations\BelongsTo;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+
+// https://github.com/framgia/laravel-test-examples/blob/master/tests/ModelTestCase.php
+abstract class ModelTestCase extends TestCase
+{
+    /**
+     * @param Model $model
+     * @param array $fillable
+     * @param array $guarded
+     * @param array $hidden
+     * @param array $visible
+     * @param array $casts
+     * @param array $dates
+     * @param string $collectionClass
+     * @param null $table
+     * @param string $primaryKey
+     * @param boolean $incrementing
+     *
+     * - `$fillable` -> `getFillable()`
+     * - `$guarded` -> `getGuarded()`
+     * - `$table` -> `getTable()`
+     * - `$primaryKey` -> `getKeyName()`
+     * - `$hidden` -> `getHidden()`
+     * - `$visible` -> `getVisible()`
+     * - `$casts` -> `getCasts()`: note that method appends incrementing key.
+     * - `$dates` -> `getDates()`: note that method appends `[static::CREATED_AT, static::UPDATED_AT]`.
+     * - `newCollection()`: assert collection is exact type. Use `assertEquals` on `get_class()` result, but not `assertInstanceOf`.
+     */
+    protected function runConfigurationAssertions(
+        Model $model,
+        $fillable = [],
+        $hidden = [],
+        $guarded = ['*'],
+        $visible = [],
+        $casts = ['id' => 'int'],
+        $dispatchesEvents = [],
+        $dates = ['created_at', 'updated_at'],
+        $collectionClass = Collection::class,
+        $table = null,
+        $primaryKey = 'id',
+        $incrementing = true)
+    {
+        $this->assertEquals($fillable, $model->getFillable());
+        $this->assertEquals($guarded, $model->getGuarded());
+        $this->assertEquals($hidden, $model->getHidden());
+        $this->assertEquals($visible, $model->getVisible());
+        $this->assertEquals($casts, $model->getCasts());
+        $this->assertEquals($dates, $model->getDates());
+        $this->assertEquals($primaryKey, $model->getKeyName());
+        $this->assertEquals($incrementing, $model->getIncrementing());
+
+        $eventDispatcher = $model->getEventDispatcher();
+        foreach ($dispatchesEvents as $eventName => $eventclass) {
+            $this->assertTrue($eventDispatcher->hasListeners($eventclass));
+        }
+
+        $c = $model->newCollection();
+        $this->assertEquals($collectionClass, get_class($c));
+        $this->assertInstanceOf(Collection::class, $c);
+
+        if ($table !== null) {
+            $this->assertEquals($table, $model->getTable());
+        }
+    }
+
+    
+    /**
+     * @param HasMany $relation
+     * @param Model $model
+     * @param Model $related
+     * @param string $key
+     * @param string $parent
+     * @param \Closure $queryCheck
+     *
+     * - `getQuery()`: assert query has not been modified or modified properly.
+     * - `getForeignKey()`: any `HasOneOrMany` or `BelongsTo` relation, but key type differs (see documentaiton).
+     * - `getQualifiedParentKeyName()`: in case of `HasOneOrMany` relation, there is no `getLocalKey()` method, so this one should be asserted.
+     */
+    protected function assertHasManyRelation($relation, Model $model, Model $related, $key = null, $parent = null, \Closure $queryCheck = null)
+    {
+        $this->assertInstanceOf(HasMany::class, $relation);
+
+        if (!is_null($queryCheck)) {
+            $queryCheck->bindTo($this);
+            $queryCheck($relation->getQuery(), $model, $relation);
+        }
+
+        if (is_null($key)) {
+            $key = $model->getForeignKey();
+        }
+
+        $this->assertEquals($key, $relation->getForeignKeyName());
+
+        if (is_null($parent)) {
+            $parent = $model->getKeyName();
+        }
+
+        $this->assertEquals($model->getTable().'.'.$parent, $relation->getQualifiedParentKeyName());
+    }
+
+
+    /**
+     * @param BelongsTo $relation
+     * @param Model $model
+     * @param Model $related
+     * @param string $key
+     * @param string $owner
+     * @param \Closure $queryCheck
+     *
+     * - `getQuery()`: assert query has not been modified or modified properly.
+     * - `getForeignKey()`: any `HasOneOrMany` or `BelongsTo` relation, but key type differs (see documentaiton).
+     * - `getOwnerKey()`: `BelongsTo` relation and its extendings.
+     */
+    protected function assertBelongsToRelation($relation, Model $model, Model $related, $key, $owner = null, \Closure $queryCheck = null)
+    {
+        $this->assertInstanceOf(BelongsTo::class, $relation);
+
+        if (!is_null($queryCheck)) {
+            $queryCheck->bindTo($this);
+            $queryCheck($relation->getQuery(), $model, $relation);
+        }
+
+        $this->assertEquals($key, $relation->getForeignKey());
+
+        if (is_null($owner)) {
+            $owner = $related->getKeyName();
+        }
+
+        $this->assertEquals($owner, $relation->getOwnerKey());
+    }
+}

tests/Unit/Api/v1/Controllers/GroupControllerTest.php

@@ -0,0 +1,186 @@
+<?php
+
+namespace Tests\Unit\Api\v1\Controllers;
+
+use App\User;
+use App\Group;
+use Tests\TestCase;
+use App\TwoFAccount;
+use App\Services\GroupService;
+use Illuminate\Foundation\Testing\WithoutMiddleware;
+use App\Api\v1\Controllers\GroupController;
+use Mockery;
+use Illuminate\Http\Request;
+use Illuminate\Http\Resources\Json\AnonymousResourceCollection;
+use App\Api\v1\Requests\GroupStoreRequest;
+
+/**
+ * @covers \App\Api\v1\Controllers\GroupController
+ */
+class GroupControllerTest extends TestCase
+{
+    use WithoutMiddleware;
+
+    /**
+     * @var \Mockery\Mock|\App\Services\GroupService
+     */
+    protected $groupServiceMock;
+
+
+    /**
+     * @var \App\Api\v1\Controllers\GroupController mocked controller
+     */
+    protected $controller;
+
+
+    /**
+     * @var \App\Api\v1\Requests\GroupStoreRequest mocked request
+     */
+    protected $groupStoreRequest;
+
+
+    public function setUp() : void
+    {
+        parent::setUp();
+
+        $this->groupServiceMock = Mockery::mock($this->app->make(GroupService::class));
+        $this->groupStoreRequest = Mockery::mock('App\Api\v1\Requests\GroupStoreRequest');
+
+        $this->controller = new GroupController($this->groupServiceMock);
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_index_returns_api_resources_using_groupService()
+    {
+        $groups = factory(Group::class, 3)->make();
+
+        $this->groupServiceMock->shouldReceive('getAll')
+            ->once()
+            ->andReturn($groups);
+
+        $response = $this->controller->index();
+
+        $this->assertContainsOnlyInstancesOf('App\Api\v1\Resources\GroupResource', $response->collection);
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_store_returns_api_resource_stored_using_groupService()
+    {
+        $group = factory(Group::class)->make();
+
+        $this->groupStoreRequest->shouldReceive('validated')
+            ->once()
+            ->andReturn(['name' => $group->name]);
+
+        $this->groupServiceMock->shouldReceive('create')
+            ->once()
+            ->andReturn($group);
+
+        $response = $this->controller->store($this->groupStoreRequest);
+
+        $this->assertInstanceOf('App\Group', $response->original);
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_show_returns_api_resource()
+    {
+        $group = factory(Group::class)->make();
+
+        $response = $this->controller->show($group);
+
+        $this->assertInstanceOf('App\Api\v1\Resources\GroupResource', $response);
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_update_returns_api_resource_updated_using_groupService()
+    {
+        $group = factory(Group::class)->make();
+
+        $this->groupStoreRequest->shouldReceive('validated')
+            ->once()
+            ->andReturn(['name' => $group->name]);
+
+        $this->groupServiceMock->shouldReceive('update')
+            ->once()
+            ->andReturn($group);
+
+        $response = $this->controller->update($this->groupStoreRequest, $group);
+
+        $this->assertInstanceOf('App\Api\v1\Resources\GroupResource', $response);
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_assignAccounts_returns_api_resource_assigned_using_groupService()
+    {
+        $group = factory(Group::class)->make();
+        $groupAssignRequest = Mockery::mock('App\Api\v1\Requests\GroupAssignRequest');
+
+        $groupAssignRequest->shouldReceive('validated')
+            ->once()
+            ->andReturn(['ids' => $group->id]);
+
+        $this->groupServiceMock->shouldReceive('assign')
+            ->with($group->id, $group)
+            ->once();
+
+        $response = $this->controller->assignAccounts($groupAssignRequest, $group);
+
+        $this->assertInstanceOf('App\Api\v1\Resources\GroupResource', $response);
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_accounts_returns_api_resources_fetched_using_groupService()
+    {
+        $group = factory(Group::class)->make();
+
+        \Facades\App\Services\SettingServiceInterface::shouldReceive('get')
+            ->with('useEncryption')
+            ->andReturn(false);
+
+        $twofaccounts = factory(TwoFAccount::class, 3)->make();
+
+        $this->groupServiceMock->shouldReceive('getAccounts')
+            ->with($group)
+            ->once()
+            ->andReturn($twofaccounts);
+
+        $response = $this->controller->accounts($group);
+        // TwoFAccountCollection
+        $this->assertContainsOnlyInstancesOf('App\Api\v1\Resources\TwoFAccountReadResource', $response->collection);
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_destroy_uses_group_service()
+    {
+        $group = factory(Group::class)->make();
+
+        $this->groupServiceMock->shouldReceive('delete')
+            ->once()
+            ->with($group->id);
+
+        $response = $this->controller->destroy($group);
+
+        $this->assertInstanceOf('Illuminate\Http\JsonResponse', $response);
+    }
+}

tests/Unit/Events/GroupDeletingTest.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Tests\Unit\Events;
+
+use App\Group;
+use App\Events\GroupDeleting;
+use Tests\TestCase;
+
+
+/**
+ * @covers \App\Events\GroupDeleting
+ */
+class GroupDeletingTest extends TestCase
+{
+    /**
+     * @test
+     */
+    public function test_event_constructor()
+    {
+        $group = factory(Group::class)->make();
+        $event = new GroupDeleting($group);
+
+        $this->assertSame($group, $event->group);
+    }
+}

tests/Unit/Events/TwoFAccountDeletedTest.php

@@ -0,0 +1,29 @@
+<?php
+
+namespace Tests\Unit\Events;
+
+use App\TwoFAccount;
+use App\Events\TwoFAccountDeleted;
+use Tests\TestCase;
+
+
+/**
+ * @covers \App\Events\TwoFAccountDeleted
+ */
+class TwoFAccountDeletedTest extends TestCase
+{
+    /**
+     * @test
+     */
+    public function test_event_constructor()
+    {
+        \Facades\App\Services\SettingServiceInterface::shouldReceive('get')
+            ->with('useEncryption')
+            ->andReturn(false);
+
+        $twofaccount = factory(TwoFAccount::class)->make();
+        $event = new TwoFAccountDeleted($twofaccount);
+
+        $this->assertSame($twofaccount, $event->twofaccount);
+    }
+}

tests/Unit/Exceptions/HandlerTest.php

@@ -0,0 +1,103 @@
+<?php
+
+namespace Tests\Unit\Exceptions;
+
+use App\Exceptions\Handler;
+use Illuminate\Http\Request;
+use Illuminate\Http\JsonResponse;
+use Illuminate\Contracts\Container\Container;
+use Tests\TestCase;
+
+
+/**
+ * @covers \App\Exceptions\Handler
+ */
+class HandlerTest extends TestCase
+{
+
+    /**
+    * @test
+    *
+    * @dataProvider provideExceptionsforBadRequest
+    */
+    public function test_exceptions_returns_badRequest_json_response($exception)
+    {
+        $request = $this->createMock(Request::class);
+        $instance = new Handler($this->createMock(Container::class));
+        $class = new \ReflectionClass(Handler::class);
+
+        $method = $class->getMethod('render');
+        $method->setAccessible(true);
+
+        $response = $method->invokeArgs($instance, [$request, $this->createMock($exception)]);
+
+        $this->assertInstanceOf(JsonResponse::class, $response);
+
+        $response = \Illuminate\Testing\TestResponse::fromBaseResponse($response);
+        $response->assertStatus(400)
+            ->assertJsonStructure([
+                'message'
+            ]);
+    }
+
+    /**
+     * Provide Valid data for validation test
+     */
+    public function provideExceptionsforBadRequest() : array
+    {
+        return [
+            [
+                '\App\Exceptions\InvalidOtpParameterException'
+            ],
+            [
+                '\App\Exceptions\InvalidQrCodeException'
+            ],
+            [
+                '\App\Exceptions\InvalidSecretException'
+            ],
+            [
+                '\App\Exceptions\DbEncryptionException'
+            ],
+        ];
+    }
+
+    /**
+    * @test
+    *
+    * @dataProvider provideExceptionsforNotFound
+    */
+    public function test_exceptions_returns_notFound_json_response($exception)
+    {
+        $request = $this->createMock(Request::class);
+        $instance = new Handler($this->createMock(Container::class));
+        $class = new \ReflectionClass(Handler::class);
+
+        $method = $class->getMethod('render');
+        $method->setAccessible(true);
+
+        $response = $method->invokeArgs($instance, [$request, $this->createMock($exception)]);
+
+        $this->assertInstanceOf(JsonResponse::class, $response);
+
+        $response = \Illuminate\Testing\TestResponse::fromBaseResponse($response);
+        $response->assertStatus(404)
+            ->assertJsonStructure([
+                'message'
+            ]);
+    }
+
+    /**
+     * Provide Valid data for validation test
+     */
+    public function provideExceptionsforNotFound() : array
+    {
+        return [
+            [
+                '\Illuminate\Database\Eloquent\ModelNotFoundException'
+            ],
+            [
+                '\Symfony\Component\HttpKernel\Exception\NotFoundHttpException'
+            ],
+        ];
+    }
+}

tests/Unit/GroupModelTest.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace Tests\Unit;
+
+use App\Group;
+use App\TwoFAccount;
+use App\Events\GroupDeleting;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+use Tests\ModelTestCase;
+
+/**
+ * @covers \App\Group
+ */
+class GroupModelTest extends ModelTestCase
+{
+
+    /**
+     * @test
+     */
+    public function test_model_configuration()
+    {
+        $this->runConfigurationAssertions(
+            new Group(),
+            ['name'],
+            ['created_at', 'updated_at'],
+            ['*'],
+            [],
+            ['id' => 'int', 'twofaccounts_count' => 'integer',],
+            ['deleting' => GroupDeleting::class]
+        );
+    }
+
+
+    /**
+     * @test
+     */
+    public function test_groups_relation()
+    {
+        $group = new Group();
+        $accounts = $group->twofaccounts();
+        $this->assertHasManyRelation($accounts, $group, new TwoFAccount());
+    }
+}

tests/Unit/Listeners/CleanIconStorageTest.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace Tests\Unit\Listeners;
+
+use App\TwoFAccount;
+use App\Events\TwoFAccountDeleted;
+use Tests\TestCase;
+use App\Listeners\CleanIconStorage;
+use Illuminate\Support\Facades\Storage;
+
+
+/**
+ * @covers \App\Listeners\CleanIconStorage
+ */
+class CleanIconStorageTest extends TestCase
+{
+    public function test_it_stores_time_to_session()
+    {
+        \Facades\App\Services\SettingServiceInterface::shouldReceive('get')
+            ->with('useEncryption')
+            ->andReturn(false);
+
+        $twofaccount = factory(TwoFAccount::class)->make();
+        $event = new TwoFAccountDeleted($twofaccount);
+        $listener = new CleanIconStorage();
+
+        Storage::shouldReceive('delete')
+            ->with('public/icons/' . $event->twofaccount->icon)
+            ->andReturn(true);
+
+        $this->assertNull($listener->handle($event));
+    }
+}

tests/Unit/Listeners/DissociateTwofaccountFromGroupTest.php

@@ -0,0 +1,26 @@
+<?php
+
+namespace Tests\Unit\Listeners;
+
+use App\Group;
+use App\TwoFAccount;
+use App\Events\GroupDeleting;
+use Tests\FeatureTestCase;
+use App\Listeners\DissociateTwofaccountFromGroup;
+use Illuminate\Support\Facades\Storage;
+
+
+/**
+ * @covers \App\Listeners\DissociateTwofaccountFromGroup
+ */
+class DissociateTwofaccountFromGroupTest extends FeatureTestCase
+{
+    public function test_it_stores_time_to_session()
+    {
+        $group = factory(Group::class)->make();
+        $event = new GroupDeleting($group);
+        $listener = new DissociateTwofaccountFromGroup();
+
+        $this->assertNull($listener->handle($event));
+    }
+}

tests/Unit/TwoFAccountModelTest.php

@@ -0,0 +1,111 @@
+<?php
+
+namespace Tests\Unit;
+
+use App\TwoFAccount;
+use App\Events\TwoFAccountDeleted;
+use Tests\ModelTestCase;
+use Illuminate\Support\Facades\Event;
+use Illuminate\Database\Eloquent\Relations\HasMany;
+use Illuminate\Support\Facades\Crypt;
+
+/**
+ * @covers \App\TwoFAccount
+ */
+class TwoFAccountModelTest extends ModelTestCase
+{
+
+    /**
+     * @test
+     */
+    public function test_model_configuration()
+    {
+        $this->runConfigurationAssertions(
+            new TwoFAccount(),
+            [],
+            [],
+            ['*'],
+            [],
+            ['id' => 'int'],
+            ['deleted' => TwoFAccountDeleted::class],
+            ['created_at', 'updated_at'],
+            \Illuminate\Database\Eloquent\Collection::class,
+            'twofaccounts',
+            'id',
+            true
+        );
+    }
+
+
+    /**
+     * @test
+     * 
+     * @dataProvider provideSensitiveAttributes
+     */
+    public function test_sensitive_attributes_are_stored_encrypted(string $attribute)
+    {
+        \Facades\App\Services\SettingServiceInterface::shouldReceive('get')
+            ->with('useEncryption')
+            ->andReturn(true);
+
+        $twofaccount = factory(TwoFAccount::class)->make([
+            $attribute => 'string',
+        ]);
+
+        $this->assertEquals('string', Crypt::decryptString($twofaccount->getAttributes()[$attribute]));
+    }
+
+    /**
+     * Provide attributes to test for encryption
+     */
+    public function provideSensitiveAttributes() : array
+    {
+        return [
+            [
+                'legacy_uri'
+            ],
+            [
+                'secret'
+            ],
+            [
+                'account'
+            ],
+        ];
+    }
+
+    /**
+     * @test
+     * 
+     * @dataProvider provideSensitiveAttributes
+     */
+    public function test_sensitive_attributes_are_returned_clear(string $attribute)
+    {
+        \Facades\App\Services\SettingServiceInterface::shouldReceive('get')
+            ->with('useEncryption')
+            ->andReturn(false);
+
+        $twofaccount = factory(TwoFAccount::class)->make();
+
+        $this->assertEquals($twofaccount->getAttributes()[$attribute], $twofaccount->$attribute);
+    }
+
+
+    /**
+     * @test
+     * 
+     * @dataProvider provideSensitiveAttributes
+     */
+    public function test_indecipherable_attributes_returns_masked_value(string $attribute)
+    {
+        \Facades\App\Services\SettingServiceInterface::shouldReceive('get')
+            ->with('useEncryption')
+            ->andReturn(true);
+
+        Crypt::shouldReceive('encryptString')
+            ->andReturn('indecipherableString');
+
+        $twofaccount = factory(TwoFAccount::class)->make();
+
+        $this->assertEquals(__('errors.indecipherable'), $twofaccount->$attribute);
+    }
+}

tests/Unit/UserModelTest.php

@@ -0,0 +1,39 @@
+<?php
+
+namespace Tests\Unit;
+
+use App\User;
+use Tests\ModelTestCase;
+
+/**
+ * @covers \App\User
+ */
+class UserModelTest extends ModelTestCase
+{
+
+    /**
+     * @test
+     */
+    public function test_model_configuration()
+    {
+        $this->runConfigurationAssertions(new User(),
+            ['name', 'email', 'password'],
+            ['password', 'remember_token'],
+            ['*'],
+            [],
+            ['id' => 'int', 'email_verified_at' => 'datetime']
+        );
+    }
+
+    /**
+     * @test
+     */
+    public function test_email_is_set_lowercased()
+    {
+        $user = factory(User::class)->make([
+            'email' => 'UPPERCASE@example.COM',
+        ]);
+
+        $this->assertEquals(strtolower('UPPERCASE@example.COM'), $user->email);
+    }
+}