diff --git a/src/tests/Browser/DomainTest.php b/src/tests/Browser/DomainTest.php
index ac2c9a19..a4b8f6a1 100644
--- a/src/tests/Browser/DomainTest.php
+++ b/src/tests/Browser/DomainTest.php
@@ -1,132 +1,132 @@
 <?php
 
 namespace Tests\Browser;
 
 use App\Domain;
 use App\User;
 use Tests\Browser;
 use Tests\Browser\Components\Toast;
 use Tests\Browser\Pages\Dashboard;
 use Tests\Browser\Pages\DomainInfo;
 use Tests\Browser\Pages\DomainList;
 use Tests\Browser\Pages\Home;
-use Tests\DuskTestCase;
+use Tests\TestCaseDusk;
 use Illuminate\Foundation\Testing\DatabaseMigrations;
 
-class DomainTest extends DuskTestCase
+class DomainTest extends TestCaseDusk
 {
 
     /**
      * Test domain info page (unauthenticated)
      */
     public function testDomainInfoUnauth(): void
     {
         // Test that the page requires authentication
         $this->browse(function ($browser) {
             $browser->visit('/domain/123')->on(new Home());
         });
     }
 
     /**
      * Test domain info page (non-existing domain id)
      */
     public function testDomainInfo404(): void
     {
         $this->browse(function ($browser) {
             // FIXME: I couldn't make loginAs() method working
 
             // Note: Here we're also testing that unauthenticated request
             //       is passed to logon form and then "redirected" to the requested page
             $browser->visit('/domain/123')
                 ->on(new Home())
                 ->submitLogon('john@kolab.org', 'simple123')
                 ->assertErrorPage(404);
         });
     }
 
     /**
      * Test domain info page (existing domain)
      *
      * @depends testDomainInfo404
      */
     public function testDomainInfo(): void
     {
         $this->browse(function ($browser) {
             // Unconfirmed domain
             $domain = Domain::where('namespace', 'kolab.org')->first();
             $domain->status ^= Domain::STATUS_CONFIRMED;
             $domain->save();
 
             $browser->visit('/domain/' . $domain->id)
                 ->on(new DomainInfo())
                 ->whenAvailable('@verify', function ($browser) use ($domain) {
                     // Make sure the domain is confirmed now
                     // TODO: Test verification process failure
                     $domain->status |= Domain::STATUS_CONFIRMED;
                     $domain->save();
 
                     $browser->assertSeeIn('pre', $domain->namespace)
                         ->assertSeeIn('pre', $domain->hash())
                         ->click('button');
                 })
                 ->whenAvailable('@config', function ($browser) use ($domain) {
                     $browser->assertSeeIn('pre', $domain->namespace);
                 })
                 ->assertMissing('@verify')
                 ->with(new Toast(Toast::TYPE_SUCCESS), function ($browser) {
                     $browser->assertToastTitle('')
                         ->assertToastMessage('Domain verified successfully')
                         ->closeToast();
                 });
 
             // Check that confirmed domain page contains only the config box
             $browser->visit('/domain/' . $domain->id)
                 ->on(new DomainInfo())
                 ->assertMissing('@verify')
                 ->assertPresent('@config');
         });
     }
 
     /**
      * Test domains list page (unauthenticated)
      */
     public function testDomainListUnauth(): void
     {
         // Test that the page requires authentication
         $this->browse(function ($browser) {
             $browser->visit('/logout')
                 ->visit('/domains')
                 ->on(new Home());
         });
     }
 
     /**
      * Test domains list page
      *
      * @depends testDomainListUnauth
      */
     public function testDomainList(): void
     {
         $this->browse(function ($browser) {
             // Login the user
             $browser->visit('/login')
                 ->on(new Home())
                 ->submitLogon('john@kolab.org', 'simple123', true)
                 // On dashboard click the "Domains" link
                 ->on(new Dashboard())
                 ->assertSeeIn('@links a.link-domains', 'Domains')
                 ->click('@links a.link-domains')
                 // On Domains List page click the domain entry
                 ->on(new DomainList())
                 ->assertSeeIn('@table tbody tr:first-child td:first-child', 'kolab.org')
                 ->click('@table tbody tr:first-child td:first-child a')
                 // On Domain Info page verify that's the clicked domain
                 ->on(new DomainInfo())
                 ->whenAvailable('@config', function ($browser) {
                     $browser->assertSeeIn('pre', 'kolab.org');
                 });
         });
 
         // TODO: Test domains list acting as Ned (John's "delegatee")
     }
 }
diff --git a/src/tests/Browser/ErrorTest.php b/src/tests/Browser/ErrorTest.php
index 4b543cf6..91fa83bb 100644
--- a/src/tests/Browser/ErrorTest.php
+++ b/src/tests/Browser/ErrorTest.php
@@ -1,36 +1,36 @@
 <?php
 
 namespace Tests\Browser;
 
 use Tests\Browser;
-use Tests\DuskTestCase;
+use Tests\TestCaseDusk;
 
-class ErrorTest extends DuskTestCase
+class ErrorTest extends TestCaseDusk
 {
 
     /**
      * Test error 404 page on unknown route
      *
      * @return void
      */
     public function testError404Page()
     {
         $this->browse(function (Browser $browser) {
             $browser->visit('/unknown');
 
             $browser->waitFor('#app > #error-page');
             $browser->assertVisible('#app > #primary-menu');
             $this->assertSame('404', $browser->text('#error-page .code'));
             $this->assertSame('Not Found', $browser->text('#error-page .message'));
         });
 
         $this->browse(function (Browser $browser) {
             $browser->visit('/login/unknown');
 
             $browser->waitFor('#app > #error-page');
             $browser->assertVisible('#app > #primary-menu');
             $this->assertSame('404', $browser->text('#error-page .code'));
             $this->assertSame('Not Found', $browser->text('#error-page .message'));
         });
     }
 }
diff --git a/src/tests/Browser/LogonTest.php b/src/tests/Browser/LogonTest.php
index b12df0ef..4d14d920 100644
--- a/src/tests/Browser/LogonTest.php
+++ b/src/tests/Browser/LogonTest.php
@@ -1,160 +1,160 @@
 <?php
 
 namespace Tests\Browser;
 
 use Tests\Browser;
 use Tests\Browser\Components\Menu;
 use Tests\Browser\Components\Toast;
 use Tests\Browser\Pages\Dashboard;
 use Tests\Browser\Pages\Home;
-use Tests\DuskTestCase;
+use Tests\TestCaseDusk;
 use Illuminate\Foundation\Testing\DatabaseMigrations;
 
-class LogonTest extends DuskTestCase
+class LogonTest extends TestCaseDusk
 {
 
     /**
      * Test menu on logon page
      */
     public function testLogonMenu(): void
     {
         $this->browse(function (Browser $browser) {
             $browser->visit(new Home());
             $browser->within(new Menu(), function ($browser) {
                 $browser->assertMenuItems(['signup', 'explore', 'blog', 'support', 'webmail']);
             });
         });
     }
 
     /**
      * Test redirect to /login if user is unauthenticated
      */
     public function testLogonRedirect(): void
     {
         $this->browse(function (Browser $browser) {
             $browser->visit('/dashboard');
 
             // Checks if we're really on the login page
             $browser->waitForLocation('/login')
                 ->on(new Home());
         });
     }
 
     /**
      * Logon with wrong password/user test
      */
     public function testLogonWrongCredentials(): void
     {
         $this->browse(function (Browser $browser) {
             $browser->visit(new Home())
                 ->submitLogon('john@kolab.org', 'wrong');
 
             // Error message
             $browser->with(new Toast(Toast::TYPE_ERROR), function (Browser $browser) {
                 $browser->assertToastTitle('Error')
                     ->assertToastMessage('Invalid username or password.')
                     ->closeToast();
             });
 
             // Checks if we're still on the logon page
             $browser->on(new Home());
         });
     }
 
     /**
      * Successful logon test
      */
     public function testLogonSuccessful(): void
     {
         $this->browse(function (Browser $browser) {
             $browser->visit(new Home())
                 ->submitLogon('john@kolab.org', 'simple123', true);
 
             // Checks if we're really on Dashboard page
             $browser->on(new Dashboard());
 
             $browser->within(new Menu(), function ($browser) {
                 $browser->assertMenuItems(['support', 'contact', 'webmail', 'logout']);
             });
 
             $browser->assertVue('data.email', 'john@kolab.org', '@dashboard-component');
 
             // TODO: Verify dashboard content
 
             // Goto /domains and assert that the link on logo element
             // leads to the dashboard
             $browser->visit('/domains')
                 ->waitForText('Domains')
                 ->click('a.navbar-brand')
                 ->on(new Dashboard());
 
             // Test that visiting '/' with logged in user does not open logon form
             // but "redirects" to the dashboard
             $browser->visit('/')->on(new Dashboard());
         });
     }
 
     /**
      * Logout test
      *
      * @depends testLogonSuccessful
      */
     public function testLogout(): void
     {
         $this->browse(function (Browser $browser) {
             $browser->on(new Dashboard());
 
             // Click the Logout button
             $browser->within(new Menu(), function ($browser) {
                 $browser->click('.link-logout');
             });
 
             // We expect the logon page
             $browser->waitForLocation('/login')
                 ->on(new Home());
 
             // with default menu
             $browser->within(new Menu(), function ($browser) {
                 $browser->assertMenuItems(['signup', 'explore', 'blog', 'support', 'webmail']);
             });
 
             // Success toast message
             $browser->with(new Toast(Toast::TYPE_SUCCESS), function (Browser $browser) {
                 $browser->assertToastTitle('')
                     ->assertToastMessage('Successfully logged out')
                     ->closeToast();
             });
         });
     }
 
     /**
      * Logout by URL test
      */
     public function testLogoutByURL(): void
     {
         $this->browse(function (Browser $browser) {
             $browser->visit(new Home())
                 ->submitLogon('john@kolab.org', 'simple123', true);
 
             // Checks if we're really on Dashboard page
             $browser->on(new Dashboard());
 
             // Use /logout url, and expect the logon page
             $browser->visit('/logout')
                 ->waitForLocation('/login')
                 ->on(new Home());
 
             // with default menu
             $browser->within(new Menu(), function ($browser) {
                 $browser->assertMenuItems(['signup', 'explore', 'blog', 'support', 'webmail']);
             });
 
             // Success toast message
             $browser->with(new Toast(Toast::TYPE_SUCCESS), function (Browser $browser) {
                 $browser->assertToastTitle('')
                     ->assertToastMessage('Successfully logged out')
                     ->closeToast();
             });
         });
     }
 }
diff --git a/src/tests/Browser/PasswordResetTest.php b/src/tests/Browser/PasswordResetTest.php
index ef1092c4..f3545a18 100644
--- a/src/tests/Browser/PasswordResetTest.php
+++ b/src/tests/Browser/PasswordResetTest.php
@@ -1,274 +1,274 @@
 <?php
 
 namespace Tests\Browser;
 
 use App\User;
 use App\VerificationCode;
 use Tests\Browser;
 use Tests\Browser\Pages\Dashboard;
 use Tests\Browser\Pages\Home;
 use Tests\Browser\Pages\PasswordReset;
-use Tests\DuskTestCase;
+use Tests\TestCaseDusk;
 use Illuminate\Foundation\Testing\DatabaseMigrations;
 
-class PasswordResetTest extends DuskTestCase
+class PasswordResetTest extends TestCaseDusk
 {
     /**
      * {@inheritDoc}
      */
     public function setUp(): void
     {
         parent::setUp();
 
         $this->deleteTestUser('passwordresettestdusk@' . \config('app.domain'));
     }
 
     /**
      * {@inheritDoc}
      */
     public function tearDown(): void
     {
         $this->deleteTestUser('passwordresettestdusk@' . \config('app.domain'));
 
         parent::tearDown();
     }
 
     /**
      * Test the link from logon to password-reset page
      */
     public function testPasswordResetLinkOnLogon(): void
     {
         $this->browse(function (Browser $browser) {
             $browser->visit(new Home());
 
             $browser->assertSeeLink('Forgot password?');
             $browser->clickLink('Forgot password?');
 
             $browser->on(new PasswordReset());
             $browser->assertVisible('@step1');
         });
     }
 
     /**
      * Test 1st step of password-reset
      */
     public function testPasswordResetStep1(): void
     {
         $user = $this->getTestUser('passwordresettestdusk@' . \config('app.domain'));
         $user->setSetting('external_email', 'external@domain.tld');
 
         $this->browse(function (Browser $browser) {
             $browser->visit(new PasswordReset());
 
             $browser->assertVisible('@step1');
 
             // Here we expect email input and submit button
             $browser->with('@step1', function ($step) {
                 $step->assertVisible('#reset_email');
                 $step->assertFocused('#reset_email');
                 $step->assertVisible('[type=submit]');
             });
 
             // Submit empty form
             $browser->with('@step1', function ($step) {
                 $step->click('[type=submit]');
                 $step->assertFocused('#reset_email');
             });
 
             // Submit invalid email
             // We expect email input to have is-invalid class added, with .invalid-feedback element
             $browser->with('@step1', function ($step) use ($browser) {
                 $step->type('#reset_email', '@test');
                 $step->click('[type=submit]');
 
                 $step->waitFor('#reset_email.is-invalid');
                 $step->waitFor('#reset_email + .invalid-feedback');
                 $browser->waitFor('.toast-error');
                 $browser->click('.toast-error'); // remove the toast
             });
 
             // Submit valid data
             $browser->with('@step1', function ($step) {
                 $step->type('#reset_email', 'passwordresettestdusk@' . \config('app.domain'));
                 $step->click('[type=submit]');
 
                 $step->assertMissing('#reset_email.is-invalid');
                 $step->assertMissing('#reset_email + .invalid-feedback');
             });
 
             $browser->waitUntilMissing('@step2 #reset_code[value=""]');
             $browser->waitFor('@step2');
             $browser->assertMissing('@step1');
         });
     }
 
     /**
      * Test 2nd Step of the password reset process
      *
      * @depends testPasswordResetStep1
      */
     public function testPasswordResetStep2(): void
     {
         $user = $this->getTestUser('passwordresettestdusk@' . \config('app.domain'));
         $user->setSetting('external_email', 'external@domain.tld');
 
         $this->browse(function (Browser $browser) {
             $browser->assertVisible('@step2');
 
             // Here we expect one text input, Back and Continue buttons
             $browser->with('@step2', function ($step) {
                 $step->assertVisible('#reset_short_code');
                 $step->assertFocused('#reset_short_code');
                 $step->assertVisible('[type=button]');
                 $step->assertVisible('[type=submit]');
             });
 
             // Test Back button functionality
             $browser->click('@step2 [type=button]');
             $browser->waitFor('@step1');
             $browser->assertFocused('@step1 #reset_email');
             $browser->assertMissing('@step2');
 
             // Submit valid Step 1 data (again)
             $browser->with('@step1', function ($step) {
                 $step->type('#reset_email', 'passwordresettestdusk@' . \config('app.domain'));
                 $step->click('[type=submit]');
             });
 
             $browser->waitFor('@step2');
             $browser->assertMissing('@step1');
 
             // Submit invalid code
             // We expect code input to have is-invalid class added, with .invalid-feedback element
             $browser->with('@step2', function ($step) use ($browser) {
                 $step->type('#reset_short_code', 'XXXXX');
                 $step->click('[type=submit]');
 
                 $browser->waitFor('.toast-error');
 
                 $step->assertVisible('#reset_short_code.is-invalid');
                 $step->assertVisible('#reset_short_code + .invalid-feedback');
                 $step->assertFocused('#reset_short_code');
 
                 $browser->click('.toast-error'); // remove the toast
             });
 
             // Submit valid code
             // We expect error state on code input to be removed, and Step 3 form visible
             $browser->with('@step2', function ($step) {
                 // Get the code and short_code from database
                 // FIXME: Find a nice way to read javascript data without using hidden inputs
                 $code = $step->value('#reset_code');
 
                 $this->assertNotEmpty($code);
 
                 $code = VerificationCode::find($code);
 
                 $step->type('#reset_short_code', $code->short_code);
                 $step->click('[type=submit]');
 
                 $step->assertMissing('#reset_short_code.is-invalid');
                 $step->assertMissing('#reset_short_code + .invalid-feedback');
             });
 
             $browser->waitFor('@step3');
             $browser->assertMissing('@step2');
         });
     }
 
     /**
      * Test 3rd Step of the password reset process
      *
      * @depends testPasswordResetStep2
      */
     public function testPasswordResetStep3(): void
     {
         $user = $this->getTestUser('passwordresettestdusk@' . \config('app.domain'));
         $user->setSetting('external_email', 'external@domain.tld');
 
         $this->browse(function (Browser $browser) {
             $browser->assertVisible('@step3');
 
             // Here we expect 2 text inputs, Back and Continue buttons
             $browser->with('@step3', function ($step) {
                 $step->assertVisible('#reset_password');
                 $step->assertVisible('#reset_confirm');
                 $step->assertVisible('[type=button]');
                 $step->assertVisible('[type=submit]');
                 $step->assertFocused('#reset_password');
             });
 
             // Test Back button
             $browser->click('@step3 [type=button]');
             $browser->waitFor('@step2');
             $browser->assertFocused('@step2 #reset_short_code');
             $browser->assertMissing('@step3');
             $browser->assertMissing('@step1');
 
             // TODO: Test form reset when going back
 
             // Because the verification code is removed in tearDown()
             // we'll start from the beginning (Step 1)
             $browser->click('@step2 [type=button]');
             $browser->waitFor('@step1');
             $browser->assertFocused('@step1 #reset_email');
             $browser->assertMissing('@step3');
             $browser->assertMissing('@step2');
 
             // Submit valid data
             $browser->with('@step1', function ($step) {
                 $step->type('#reset_email', 'passwordresettestdusk@' . \config('app.domain'));
                 $step->click('[type=submit]');
             });
 
             $browser->waitFor('@step2');
             $browser->waitUntilMissing('@step2 #reset_code[value=""]');
 
             // Submit valid code again
             $browser->with('@step2', function ($step) {
                 $code = $step->value('#reset_code');
 
                 $this->assertNotEmpty($code);
 
                 $code = VerificationCode::find($code);
 
                 $step->type('#reset_short_code', $code->short_code);
                 $step->click('[type=submit]');
             });
 
             $browser->waitFor('@step3');
 
             // Submit invalid data
             $browser->with('@step3', function ($step) use ($browser) {
                 $step->assertFocused('#reset_password');
 
                 $step->type('#reset_password', '12345678');
                 $step->type('#reset_confirm', '123456789');
 
                 $step->click('[type=submit]');
 
                 $browser->waitFor('.toast-error');
 
                 $step->assertVisible('#reset_password.is-invalid');
                 $step->assertVisible('#reset_password + .invalid-feedback');
                 $step->assertFocused('#reset_password');
 
                 $browser->click('.toast-error'); // remove the toast
             });
 
             // Submit valid data
             $browser->with('@step3', function ($step) {
                 $step->type('#reset_confirm', '12345678');
 
                 $step->click('[type=submit]');
             });
 
             $browser->waitUntilMissing('@step3');
 
             // At this point we should be auto-logged-in to dashboard
             $browser->on(new Dashboard());
 
             // FIXME: Is it enough to be sure user is logged in?
         });
     }
 }
diff --git a/src/tests/Browser/SignupTest.php b/src/tests/Browser/SignupTest.php
index 0c1e5b1e..7ce95e83 100644
--- a/src/tests/Browser/SignupTest.php
+++ b/src/tests/Browser/SignupTest.php
@@ -1,502 +1,502 @@
 <?php
 
 namespace Tests\Browser;
 
 use App\Domain;
 use App\SignupCode;
 use App\User;
 use Tests\Browser;
 use Tests\Browser\Components\Menu;
 use Tests\Browser\Components\Toast;
 use Tests\Browser\Pages\Dashboard;
 use Tests\Browser\Pages\Signup;
-use Tests\DuskTestCase;
+use Tests\TestCaseDusk;
 use Illuminate\Foundation\Testing\DatabaseMigrations;
 
-class SignupTest extends DuskTestCase
+class SignupTest extends TestCaseDusk
 {
     /**
      * {@inheritDoc}
      */
     public function setUp(): void
     {
         parent::setUp();
 
         $this->deleteTestUser('signuptestdusk@' . \config('app.domain'));
         $this->deleteTestUser('admin@user-domain-signup.com');
         $this->deleteTestDomain('user-domain-signup.com');
     }
 
     public function tearDown(): void
     {
         $this->deleteTestUser('signuptestdusk@' . \config('app.domain'));
         $this->deleteTestUser('admin@user-domain-signup.com');
         $this->deleteTestDomain('user-domain-signup.com');
 
         parent::tearDown();
     }
 
     /**
      * Test signup code verification with a link
      */
     public function testSignupCodeByLink(): void
     {
         // Test invalid code (invalid format)
         $this->browse(function (Browser $browser) {
             // Register Signup page element selectors we'll be using
             $browser->onWithoutAssert(new Signup());
 
             // TODO: Test what happens if user is logged in
 
             $browser->visit('/signup/invalid-code');
 
             // TODO: According to https://github.com/vuejs/vue-router/issues/977
             // it is not yet easily possible to display error page component (route)
             // without changing the URL
             // TODO: Instead of css selector we should probably define page/component
             // and use it instead
             $browser->waitFor('#error-page');
         });
 
         // Test invalid code (valid format)
         $this->browse(function (Browser $browser) {
             $browser->visit('/signup/XXXXX-code');
 
             // FIXME: User will not be able to continue anyway, so we should
             //        either display 1st step or 404 error page
             $browser->waitFor('@step1')
                 ->with(new Toast(Toast::TYPE_ERROR), function (Browser $browser) {
                     $browser->assertToastTitle('Error')
                         ->assertToastMessage('Form validation error')
                         ->closeToast();
                 });
         });
 
         // Test valid code
         $this->browse(function (Browser $browser) {
             $code = SignupCode::create([
                     'data' => [
                         'email' => 'User@example.org',
                         'name' => 'User Name',
                         'plan' => 'individual',
                     ]
             ]);
 
             $browser->visit('/signup/' . $code->short_code . '-' . $code->code);
 
             $browser->waitFor('@step3');
             $browser->assertMissing('@step1');
             $browser->assertMissing('@step2');
 
             // FIXME: Find a nice way to read javascript data without using hidden inputs
             $this->assertSame($code->code, $browser->value('@step2 #signup_code'));
 
             // TODO: Test if the signup process can be completed
         });
     }
 
     /**
      * Test signup "welcome" page
      */
     public function testSignupStep0(): void
     {
         $this->browse(function (Browser $browser) {
             $browser->visit(new Signup());
 
             $browser->assertVisible('@step0')
                 ->assertMissing('@step1')
                 ->assertMissing('@step2')
                 ->assertMissing('@step3');
 
             $browser->within(new Menu(), function ($browser) {
                 $browser->assertMenuItems(['signup', 'explore', 'blog', 'support', 'login']);
                 $browser->assertActiveItem('signup');
             });
 
             $browser->waitFor('@step0 .plan-selector > .plan-box');
 
             // Assert first plan box and press the button
             $browser->with('@step0 .plan-selector > .plan-individual', function ($step) {
                 $step->assertVisible('button')
                     ->assertSeeIn('button', 'Individual Account')
                     ->assertVisible('.plan-description')
                     ->click('button');
             });
 
             $browser->waitForLocation('/signup/individual')
                 ->assertVisible('@step1')
                 ->assertMissing('@step0')
                 ->assertMissing('@step2')
                 ->assertMissing('@step3')
                 ->assertFocused('@step1 #signup_name');
 
             // Click Back button
             $browser->click('@step1 [type=button]')
                 ->waitForLocation('/signup')
                     ->assertVisible('@step0')
                     ->assertMissing('@step1')
                     ->assertMissing('@step2')
                     ->assertMissing('@step3');
 
             // Choose the group account plan
             $browser->click('@step0 .plan-selector > .plan-group button')
                 ->waitForLocation('/signup/group')
                 ->assertVisible('@step1')
                 ->assertMissing('@step0')
                 ->assertMissing('@step2')
                 ->assertMissing('@step3')
                 ->assertFocused('@step1 #signup_name');
 
             // TODO: Test if 'plan' variable is set properly in vue component
         });
     }
 
     /**
      * Test 1st step of the signup process
      */
     public function testSignupStep1(): void
     {
         $this->browse(function (Browser $browser) {
             $browser->visit('/signup/individual')->onWithoutAssert(new Signup());
 
             $browser->assertVisible('@step1');
 
             $browser->within(new Menu(), function ($browser) {
                 $browser->assertMenuItems(['signup', 'explore', 'blog', 'support', 'login']);
                 $browser->assertActiveItem('signup');
             });
 
             // Here we expect two text inputs and Back and Continue buttons
             $browser->with('@step1', function ($step) {
                 $step->assertVisible('#signup_name')
                     ->assertFocused('#signup_name')
                     ->assertVisible('#signup_email')
                     ->assertVisible('[type=button]')
                     ->assertVisible('[type=submit]');
             });
 
             // Submit empty form
             // Both Step 1 inputs are required, so after pressing Submit
             // we expect focus to be moved to the first input
             $browser->with('@step1', function ($step) {
                 $step->click('[type=submit]');
                 $step->assertFocused('#signup_name');
             });
 
             // Submit invalid email
             // We expect email input to have is-invalid class added, with .invalid-feedback element
             $browser->with('@step1', function ($step) use ($browser) {
                 $step->type('#signup_name', 'Test User')
                     ->type('#signup_email', '@test')
                     ->click('[type=submit]')
                     ->waitFor('#signup_email.is-invalid')
                     ->assertVisible('#signup_email + .invalid-feedback');
 
                 $browser->with(new Toast(Toast::TYPE_ERROR), function (Browser $browser) {
                     $browser->assertToastTitle('Error')
                         ->assertToastMessage('Form validation error')
                         ->closeToast();
                 });
             });
 
             // Submit valid data
             // We expect error state on email input to be removed, and Step 2 form visible
             $browser->with('@step1', function ($step) {
                 $step->type('#signup_name', 'Test User');
                 $step->type('#signup_email', 'BrowserSignupTestUser1@kolab.org');
                 $step->click('[type=submit]');
 
                 $step->assertMissing('#signup_email.is-invalid');
                 $step->assertMissing('#signup_email + .invalid-feedback');
             });
 
             $browser->waitUntilMissing('@step2 #signup_code[value=""]');
             $browser->waitFor('@step2');
             $browser->assertMissing('@step1');
         });
     }
 
     /**
      * Test 2nd Step of the signup process
      *
      * @depends testSignupStep1
      */
     public function testSignupStep2(): void
     {
         $this->browse(function (Browser $browser) {
             $browser->assertVisible('@step2')
                 ->assertMissing('@step0')
                 ->assertMissing('@step1')
                 ->assertMissing('@step3');
 
             // Here we expect one text input, Back and Continue buttons
             $browser->with('@step2', function ($step) {
                 $step->assertVisible('#signup_short_code')
                     ->assertFocused('#signup_short_code')
                     ->assertVisible('[type=button]')
                     ->assertVisible('[type=submit]');
             });
 
             // Test Back button functionality
             $browser->click('@step2 [type=button]')
                 ->waitFor('@step1')
                 ->assertFocused('@step1 #signup_name')
                 ->assertMissing('@step2');
 
             // Submit valid Step 1 data (again)
             $browser->with('@step1', function ($step) {
                 $step->type('#signup_name', 'Test User');
                 $step->type('#signup_email', 'BrowserSignupTestUser1@kolab.org');
                 $step->click('[type=submit]');
             });
 
             $browser->waitFor('@step2');
             $browser->assertMissing('@step1');
 
             // Submit invalid code
             // We expect code input to have is-invalid class added, with .invalid-feedback element
             $browser->with('@step2', function ($step) use ($browser) {
                 $step->type('#signup_short_code', 'XXXXX');
                 $step->click('[type=submit]');
 
                 $step->waitFor('#signup_short_code.is-invalid')
                     ->assertVisible('#signup_short_code + .invalid-feedback')
                     ->assertFocused('#signup_short_code');
 
                 $browser->with(new Toast(Toast::TYPE_ERROR), function (Browser $browser) {
                     $browser->assertToastTitle('Error')
                         ->assertToastMessage('Form validation error')
                         ->closeToast();
                 });
             });
 
             // Submit valid code
             // We expect error state on code input to be removed, and Step 3 form visible
             $browser->with('@step2', function ($step) {
                 // Get the code and short_code from database
                 // FIXME: Find a nice way to read javascript data without using hidden inputs
                 $code = $step->value('#signup_code');
 
                 $this->assertNotEmpty($code);
 
                 $code = SignupCode::find($code);
 
                 $step->type('#signup_short_code', $code->short_code);
                 $step->click('[type=submit]');
 
                 $step->assertMissing('#signup_short_code.is-invalid');
                 $step->assertMissing('#signup_short_code + .invalid-feedback');
             });
 
             $browser->waitFor('@step3');
             $browser->assertMissing('@step2');
         });
     }
 
     /**
      * Test 3rd Step of the signup process
      *
      * @depends testSignupStep2
      */
     public function testSignupStep3(): void
     {
         $this->browse(function (Browser $browser) {
             $browser->assertVisible('@step3');
 
             // Here we expect 3 text inputs, Back and Continue buttons
             $browser->with('@step3', function ($step) {
                 $step->assertVisible('#signup_login');
                 $step->assertVisible('#signup_password');
                 $step->assertVisible('#signup_confirm');
                 $step->assertVisible('select#signup_domain');
                 $step->assertVisible('[type=button]');
                 $step->assertVisible('[type=submit]');
                 $step->assertFocused('#signup_login');
                 $step->assertValue('select#signup_domain', \config('app.domain'));
                 $step->assertValue('#signup_login', '');
                 $step->assertValue('#signup_password', '');
                 $step->assertValue('#signup_confirm', '');
 
                 // TODO: Test domain selector
             });
 
             // Test Back button
             $browser->click('@step3 [type=button]');
             $browser->waitFor('@step2');
             $browser->assertFocused('@step2 #signup_short_code');
             $browser->assertMissing('@step3');
 
             // TODO: Test form reset when going back
 
             // Submit valid code again
             $browser->with('@step2', function ($step) {
                 $code = $step->value('#signup_code');
 
                 $this->assertNotEmpty($code);
 
                 $code = SignupCode::find($code);
 
                 $step->type('#signup_short_code', $code->short_code);
                 $step->click('[type=submit]');
             });
 
             $browser->waitFor('@step3');
 
             // Submit invalid data
             $browser->with('@step3', function ($step) use ($browser) {
                 $step->assertFocused('#signup_login')
                     ->type('#signup_login', '*')
                     ->type('#signup_password', '12345678')
                     ->type('#signup_confirm', '123456789')
                     ->click('[type=submit]')
                     ->waitFor('#signup_login.is-invalid')
                     ->assertVisible('#signup_domain + .invalid-feedback')
                     ->assertVisible('#signup_password.is-invalid')
                     ->assertVisible('#signup_password + .invalid-feedback')
                     ->assertFocused('#signup_login');
 
                 $browser->with(new Toast(Toast::TYPE_ERROR), function (Browser $browser) {
                     $browser->assertToastTitle('Error')
                         ->assertToastMessage('Form validation error')
                         ->closeToast();
                 });
             });
 
             // Submit invalid data (valid login, invalid password)
             $browser->with('@step3', function ($step) use ($browser) {
                 $step->type('#signup_login', 'SignupTestDusk')
                     ->click('[type=submit]')
                     ->waitFor('#signup_password.is-invalid')
                     ->assertVisible('#signup_password + .invalid-feedback')
                     ->assertMissing('#signup_login.is-invalid')
                     ->assertMissing('#signup_domain + .invalid-feedback')
                     ->assertFocused('#signup_password');
 
                 $browser->with(new Toast(Toast::TYPE_ERROR), function (Browser $browser) {
                     $browser->assertToastTitle('Error')
                         ->assertToastMessage('Form validation error')
                         ->closeToast();
                 });
             });
 
             // Submit valid data
             $browser->with('@step3', function ($step) {
                 $step->type('#signup_confirm', '12345678');
 
                 $step->click('[type=submit]');
             });
 
             // At this point we should be auto-logged-in to dashboard
             $browser->waitUntilMissing('@step3')
                 ->waitUntilMissing('.app-loader')
                 ->on(new Dashboard())
                 ->assertVue('data.email', 'signuptestdusk@' . \config('app.domain'), '@dashboard-component');
 
             // Logout the user
             $browser->click('a.link-logout');
         });
     }
 
     /**
      * Test signup for a group account
      */
     public function testSignupGroup(): void
     {
         $this->browse(function (Browser $browser) {
             $browser->visit(new Signup());
 
             // Choose the group account plan
             $browser->waitFor('@step0 .plan-group button')
                 ->click('@step0 .plan-group button');
 
             // Submit valid data
             // We expect error state on email input to be removed, and Step 2 form visible
             $browser->whenAvailable('@step1', function ($step) {
                 $step->type('#signup_name', 'Test User')
                     ->type('#signup_email', 'BrowserSignupTestUser1@kolab.org')
                     ->click('[type=submit]');
             });
 
             // Submit valid code
             $browser->whenAvailable('@step2', function ($step) {
                 // Get the code and short_code from database
                 // FIXME: Find a nice way to read javascript data without using hidden inputs
                 $code = $step->value('#signup_code');
                 $code = SignupCode::find($code);
 
                 $step->type('#signup_short_code', $code->short_code)
                     ->click('[type=submit]');
             });
 
             // Here we expect 4 text inputs, Back and Continue buttons
             $browser->whenAvailable('@step3', function ($step) {
                 $step->assertVisible('#signup_login')
                     ->assertVisible('#signup_password')
                     ->assertVisible('#signup_confirm')
                     ->assertVisible('input#signup_domain')
                     ->assertVisible('[type=button]')
                     ->assertVisible('[type=submit]')
                     ->assertFocused('#signup_login')
                     ->assertValue('input#signup_domain', '')
                     ->assertValue('#signup_login', '')
                     ->assertValue('#signup_password', '')
                     ->assertValue('#signup_confirm', '');
             });
 
             // Submit invalid login and password data
             $browser->with('@step3', function ($step) use ($browser) {
                 $step->assertFocused('#signup_login')
                     ->type('#signup_login', '*')
                     ->type('#signup_domain', 'test.com')
                     ->type('#signup_password', '12345678')
                     ->type('#signup_confirm', '123456789')
                     ->click('[type=submit]')
                     ->waitFor('#signup_login.is-invalid')
                     ->assertVisible('#signup_domain + .invalid-feedback')
                     ->assertVisible('#signup_password.is-invalid')
                     ->assertVisible('#signup_password + .invalid-feedback')
                     ->assertFocused('#signup_login');
 
                 $browser->with(new Toast(Toast::TYPE_ERROR), function (Browser $browser) {
                     $browser->assertToastTitle('Error')
                         ->assertToastMessage('Form validation error')
                         ->closeToast();
                 });
             });
 
             // Submit invalid domain
             $browser->with('@step3', function ($step) use ($browser) {
                 $step->type('#signup_login', 'admin')
                     ->type('#signup_domain', 'aaa')
                     ->type('#signup_password', '12345678')
                     ->type('#signup_confirm', '12345678')
                     ->click('[type=submit]')
                     ->waitUntilMissing('#signup_login.is-invalid')
                     ->assertVisible('#signup_domain.is-invalid + .invalid-feedback')
                     ->assertMissing('#signup_password.is-invalid')
                     ->assertMissing('#signup_password + .invalid-feedback')
                     ->assertFocused('#signup_domain');
 
                 $browser->with(new Toast(Toast::TYPE_ERROR), function (Browser $browser) {
                     $browser->assertToastTitle('Error')
                         ->assertToastMessage('Form validation error')
                         ->closeToast();
                 });
             });
 
             // Submit invalid domain
             $browser->with('@step3', function ($step) {
                 $step->type('#signup_domain', 'user-domain-signup.com')
                     ->click('[type=submit]');
             });
 
             // At this point we should be auto-logged-in to dashboard
             $browser->waitUntilMissing('@step3')
                 ->waitUntilMissing('.app-loader')
                 ->on(new Dashboard())
                 ->assertVue('data.email', 'admin@user-domain-signup.com', '@dashboard-component');
 
             $browser->click('a.link-logout');
         });
     }
 }
diff --git a/src/tests/Browser/UserProfileTest.php b/src/tests/Browser/UserProfileTest.php
index a7dba0d5..2b44ee02 100644
--- a/src/tests/Browser/UserProfileTest.php
+++ b/src/tests/Browser/UserProfileTest.php
@@ -1,199 +1,199 @@
 <?php
 
 namespace Tests\Browser;
 
 use App\User;
 use Tests\Browser;
 use Tests\Browser\Components\Toast;
 use Tests\Browser\Pages\Dashboard;
 use Tests\Browser\Pages\Home;
 use Tests\Browser\Pages\UserProfile;
-use Tests\DuskTestCase;
+use Tests\TestCaseDusk;
 use Illuminate\Foundation\Testing\DatabaseMigrations;
 
-class UserProfileTest extends DuskTestCase
+class UserProfileTest extends TestCaseDusk
 {
     private $profile = [
         'first_name' => 'John',
         'last_name' => 'Doe',
         'currency' => 'USD',
         'country' => 'US',
         'billing_address' => "601 13th Street NW\nSuite 900 South\nWashington, DC 20005",
         'external_email' => 'john.doe.external@gmail.com',
         'phone' => '+1 509-248-1111',
     ];
 
     /**
      * {@inheritDoc}
      */
     public function setUp(): void
     {
         parent::setUp();
 
         User::where('email', 'john@kolab.org')->first()->setSettings($this->profile);
         $this->deleteTestUser('profile-delete@kolabnow.com');
     }
 
     /**
      * {@inheritDoc}
      */
     public function tearDown(): void
     {
         User::where('email', 'john@kolab.org')->first()->setSettings($this->profile);
         $this->deleteTestUser('profile-delete@kolabnow.com');
 
         parent::tearDown();
     }
 
     /**
      * Test profile page (unauthenticated)
      */
     public function testProfileUnauth(): void
     {
         // Test that the page requires authentication
         $this->browse(function (Browser $browser) {
             $browser->visit('/profile')->on(new Home());
         });
     }
 
     /**
      * Test profile page
      */
     public function testProfile(): void
     {
         $this->browse(function (Browser $browser) {
             $browser->visit(new Home())
                 ->submitLogon('john@kolab.org', 'simple123', true)
                 ->on(new Dashboard())
                 ->assertSeeIn('@links .link-profile', 'Your profile')
                 ->click('@links .link-profile')
                 ->on(new UserProfile())
                 ->assertSeeIn('#user-profile .button-delete', 'Delete account')
                 ->whenAvailable('@form', function (Browser $browser) {
                     // Assert form content
                     $browser->assertFocused('div.row:nth-child(1) input')
                         ->assertSeeIn('div.row:nth-child(1) label', 'First name')
                         ->assertValue('div.row:nth-child(1) input[type=text]', $this->profile['first_name'])
                         ->assertSeeIn('div.row:nth-child(2) label', 'Last name')
                         ->assertValue('div.row:nth-child(2) input[type=text]', $this->profile['last_name'])
                         ->assertSeeIn('div.row:nth-child(3) label', 'Phone')
                         ->assertValue('div.row:nth-child(3) input[type=text]', $this->profile['phone'])
                         ->assertSeeIn('div.row:nth-child(4) label', 'External email')
                         ->assertValue('div.row:nth-child(4) input[type=text]', $this->profile['external_email'])
                         ->assertSeeIn('div.row:nth-child(5) label', 'Address')
                         ->assertValue('div.row:nth-child(5) textarea', $this->profile['billing_address'])
                         ->assertSeeIn('div.row:nth-child(6) label', 'Country')
                         ->assertValue('div.row:nth-child(6) select', $this->profile['country'])
                         ->assertSeeIn('div.row:nth-child(7) label', 'Password')
                         ->assertValue('div.row:nth-child(7) input[type=password]', '')
                         ->assertSeeIn('div.row:nth-child(8) label', 'Confirm password')
                         ->assertValue('div.row:nth-child(8) input[type=password]', '')
                         ->assertSeeIn('button[type=submit]', 'Submit');
 
                     // Clear all fields and submit
                     // FIXME: Should any of these fields be required?
                     $browser->type('#first_name', '')
                         ->type('#last_name', '')
                         ->type('#phone', '')
                         ->type('#external_email', '')
                         ->type('#billing_address', '')
                         ->select('#country', '')
                         ->click('button[type=submit]');
                 })
                 ->with(new Toast(Toast::TYPE_SUCCESS), function (Browser $browser) {
                     $browser->assertToastTitle('')
                         ->assertToastMessage('User data updated successfully')
                         ->closeToast();
                 });
 
             // Test error handling
             $browser->with('@form', function (Browser $browser) {
                 $browser->type('#phone', 'aaaaaa')
                     ->type('#external_email', 'bbbbb')
                     ->click('button[type=submit]')
                     ->waitFor('#phone + .invalid-feedback')
                     ->assertSeeIn('#phone + .invalid-feedback', 'The phone format is invalid.')
                     ->assertSeeIn(
                         '#external_email + .invalid-feedback',
                         'The external email must be a valid email address.'
                     )
                     ->assertFocused('#phone');
             })
             ->with(new Toast(Toast::TYPE_ERROR), function (Browser $browser) {
                 $browser->assertToastTitle('Error')
                     ->assertToastMessage('Form validation error')
                     ->closeToast();
             });
         });
     }
 
     /**
      * Test profile of non-controller user
      */
     public function testProfileNonController(): void
     {
         // Test acting as non-controller
         $this->browse(function (Browser $browser) {
             $browser->visit('/logout')
                 ->visit(new Home())
                 ->submitLogon('jack@kolab.org', 'simple123', true)
                 ->on(new Dashboard())
                 ->assertSeeIn('@links .link-profile', 'Your profile')
                 ->click('@links .link-profile')
                 ->on(new UserProfile())
                 ->assertMissing('#user-profile .button-delete')
                 ->whenAvailable('@form', function (Browser $browser) {
                     // TODO: decide on what fields the non-controller user should be able
                     //       to see/change
                 });
 
             // Test that /profile/delete page is not accessible
             $browser->visit('/profile/delete')
                 ->assertErrorPage(403);
         });
     }
 
     /**
      * Test profile delete page
      */
     public function testProfileDelete(): void
     {
         $user = $this->getTestUser('profile-delete@kolabnow.com', ['password' => 'simple123']);
 
         $this->browse(function (Browser $browser) use ($user) {
             $browser->visit('/logout')
                 ->on(new Home())
                 ->submitLogon('profile-delete@kolabnow.com', 'simple123', true)
                 ->on(new Dashboard())
                 ->clearToasts()
                 ->assertSeeIn('@links .link-profile', 'Your profile')
                 ->click('@links .link-profile')
                 ->on(new UserProfile())
                 ->click('#user-profile .button-delete')
                 ->waitForLocation('/profile/delete')
                 ->assertSeeIn('#user-delete .card-title', 'Delete this account?')
                 ->assertSeeIn('#user-delete .button-cancel', 'Cancel')
                 ->assertSeeIn('#user-delete .card-text', 'This operation is irreversible')
                 ->assertFocused('#user-delete .button-cancel')
                 ->click('#user-delete .button-cancel')
                 ->waitForLocation('/profile')
                 ->on(new UserProfile());
 
             // Test deleting the user
             $browser->click('#user-profile .button-delete')
                 ->waitForLocation('/profile/delete')
                 ->click('#user-delete .button-delete')
                 ->waitForLocation('/login')
                 ->with(new Toast(Toast::TYPE_SUCCESS), function (Browser $browser) {
                     $browser->assertToastTitle('')
                         ->assertToastMessage('User deleted successfully.')
                         ->closeToast();
                 });
 
             $this->assertTrue($user->fresh()->trashed());
         });
     }
 
     // TODO: Test that Ned (John's "delegatee") can delete himself
     // TODO: Test that Ned (John's "delegatee") can/can't delete John ?
 }
diff --git a/src/tests/Browser/UsersTest.php b/src/tests/Browser/UsersTest.php
index 7c9ce4c2..052b9eb4 100644
--- a/src/tests/Browser/UsersTest.php
+++ b/src/tests/Browser/UsersTest.php
@@ -1,399 +1,399 @@
 <?php
 
 namespace Tests\Browser;
 
 use App\User;
 use App\UserAlias;
 use Tests\Browser;
 use Tests\Browser\Components\Dialog;
 use Tests\Browser\Components\ListInput;
 use Tests\Browser\Components\Toast;
 use Tests\Browser\Pages\Dashboard;
 use Tests\Browser\Pages\Home;
 use Tests\Browser\Pages\UserInfo;
 use Tests\Browser\Pages\UserList;
-use Tests\DuskTestCase;
+use Tests\TestCaseDusk;
 use Illuminate\Foundation\Testing\DatabaseMigrations;
 
-class UsersTest extends DuskTestCase
+class UsersTest extends TestCaseDusk
 {
     private $profile = [
         'first_name' => 'John',
         'last_name' => 'Doe',
     ];
 
     /**
      * {@inheritDoc}
      */
     public function setUp(): void
     {
         parent::setUp();
 
         $this->deleteTestUser('julia.roberts@kolab.org');
 
         $john = User::where('email', 'john@kolab.org')->first();
         $john->setSettings($this->profile);
         UserAlias::where('user_id', $john->id)
             ->where('alias', 'john.test@kolab.org')->delete();
     }
 
     /**
      * {@inheritDoc}
      */
     public function tearDown(): void
     {
         $this->deleteTestUser('julia.roberts@kolab.org');
 
         $john = User::where('email', 'john@kolab.org')->first();
         $john->setSettings($this->profile);
         UserAlias::where('user_id', $john->id)
             ->where('alias', 'john.test@kolab.org')->delete();
 
         parent::tearDown();
     }
 
     /**
      * Test user info page (unauthenticated)
      */
     public function testInfoUnauth(): void
     {
         // Test that the page requires authentication
         $this->browse(function (Browser $browser) {
             $user = User::where('email', 'john@kolab.org')->first();
 
             $browser->visit('/user/' . $user->id)->on(new Home());
         });
     }
 
     /**
      * Test users list page (unauthenticated)
      */
     public function testListUnauth(): void
     {
         // Test that the page requires authentication
         $this->browse(function (Browser $browser) {
             $browser->visit('/users')->on(new Home());
         });
     }
 
     /**
      * Test users list page
      */
     public function testList(): void
     {
         // Test that the page requires authentication
         $this->browse(function (Browser $browser) {
             $browser->visit(new Home())
                 ->submitLogon('john@kolab.org', 'simple123', true)
                 ->on(new Dashboard())
                 ->assertSeeIn('@links .link-users', 'User accounts')
                 ->click('@links .link-users')
                 ->on(new UserList())
                 ->whenAvailable('@table', function (Browser $browser) {
                     $browser->assertElementsCount('tbody tr', 3)
                         ->assertSeeIn('tbody tr:nth-child(1) a', 'jack@kolab.org')
                         ->assertSeeIn('tbody tr:nth-child(2) a', 'john@kolab.org')
                         ->assertSeeIn('tbody tr:nth-child(3) a', 'ned@kolab.org')
                         ->assertVisible('tbody tr:nth-child(1) button.button-delete')
                         ->assertVisible('tbody tr:nth-child(2) button.button-delete')
                         ->assertVisible('tbody tr:nth-child(3) button.button-delete');
                 });
         });
     }
 
     /**
      * Test user account editing page (not profile page)
      *
      * @depends testList
      */
     public function testInfo(): void
     {
         $this->browse(function (Browser $browser) {
             $browser->on(new UserList())
                 ->click('@table tr:nth-child(2) a')
                 ->on(new UserInfo())
                 ->assertSeeIn('#user-info .card-title', 'User account')
                 ->with('@form', function (Browser $browser) {
                     // Assert form content
                     $browser->assertFocused('div.row:nth-child(1) input')
                         ->assertSeeIn('div.row:nth-child(1) label', 'First name')
                         ->assertValue('div.row:nth-child(1) input[type=text]', $this->profile['first_name'])
                         ->assertSeeIn('div.row:nth-child(2) label', 'Last name')
                         ->assertValue('div.row:nth-child(2) input[type=text]', $this->profile['last_name'])
                         ->assertSeeIn('div.row:nth-child(3) label', 'Email')
                         ->assertValue('div.row:nth-child(3) input[type=text]', 'john@kolab.org')
                         ->assertDisabled('div.row:nth-child(3) input[type=text]')
                         ->assertSeeIn('div.row:nth-child(4) label', 'Email aliases')
                         ->assertVisible('div.row:nth-child(4) .listinput-widget')
                         ->with(new ListInput('#aliases'), function (Browser $browser) {
                             $browser->assertListInputValue(['john.doe@kolab.org'])
                                 ->assertValue('@input', '');
                         })
                         ->assertSeeIn('div.row:nth-child(5) label', 'Password')
                         ->assertValue('div.row:nth-child(5) input[type=password]', '')
                         ->assertSeeIn('div.row:nth-child(6) label', 'Confirm password')
                         ->assertValue('div.row:nth-child(6) input[type=password]', '')
                         ->assertSeeIn('button[type=submit]', 'Submit');
 
                     // Clear some fields and submit
                     $browser->type('#first_name', '')
                         ->type('#last_name', '')
                         ->click('button[type=submit]');
                 })
                 ->with(new Toast(Toast::TYPE_SUCCESS), function (Browser $browser) {
                     $browser->assertToastTitle('')
                         ->assertToastMessage('User data updated successfully')
                         ->closeToast();
                 });
 
             // Test error handling (password)
             $browser->with('@form', function (Browser $browser) {
                 $browser->type('#password', 'aaaaaa')
                     ->type('#password_confirmation', '')
                     ->click('button[type=submit]')
                     ->waitFor('#password + .invalid-feedback')
                     ->assertSeeIn('#password + .invalid-feedback', 'The password confirmation does not match.')
                     ->assertFocused('#password');
             })
             ->with(new Toast(Toast::TYPE_ERROR), function (Browser $browser) {
                 $browser->assertToastTitle('Error')
                     ->assertToastMessage('Form validation error')
                     ->closeToast();
             });
 
             // TODO: Test password change
 
             // Test form error handling (aliases)
             $browser->with('@form', function (Browser $browser) {
                 // TODO: For some reason, clearing the input value
                 // with ->type('#password', '') does not work, maybe some dusk/vue intricacy
                 // For now we just use the default password
                 $browser->type('#password', 'simple123')
                     ->type('#password_confirmation', 'simple123')
                     ->with(new ListInput('#aliases'), function (Browser $browser) {
                         $browser->addListEntry('invalid address');
                     })
                     ->click('button[type=submit]');
             })
             ->with(new Toast(Toast::TYPE_ERROR), function (Browser $browser) {
                 $browser->assertToastTitle('Error')
                     ->assertToastMessage('Form validation error')
                     ->closeToast();
             })
             ->with('@form', function (Browser $browser) {
                 $browser->with(new ListInput('#aliases'), function (Browser $browser) {
                     $browser->assertFormError(2, 'The specified alias is invalid.', false);
                 });
             });
 
             // Test adding aliases
             $browser->with('@form', function (Browser $browser) {
                 $browser->with(new ListInput('#aliases'), function (Browser $browser) {
                     $browser->removeListEntry(2)
                         ->addListEntry('john.test@kolab.org');
                 })
                     ->click('button[type=submit]');
             })
             ->with(new Toast(Toast::TYPE_SUCCESS), function (Browser $browser) {
                 $browser->assertToastTitle('')
                     ->assertToastMessage('User data updated successfully')
                     ->closeToast();
             });
 
             $john = User::where('email', 'john@kolab.org')->first();
             $alias = UserAlias::where('user_id', $john->id)->where('alias', 'john.test@kolab.org')->first();
             $this->assertTrue(!empty($alias));
         });
     }
 
     /**
      * Test user adding page
      *
      * @depends testList
      */
     public function testNewUser(): void
     {
         $this->browse(function (Browser $browser) {
             $browser->visit(new UserList())
                 ->assertSeeIn('button.create-user', 'Create user')
                 ->click('button.create-user')
                 ->on(new UserInfo())
                 ->assertSeeIn('#user-info .card-title', 'New user account')
                 ->with('@form', function (Browser $browser) {
                     // Assert form content
                     $browser->assertFocused('div.row:nth-child(1) input')
                         ->assertSeeIn('div.row:nth-child(1) label', 'First name')
                         ->assertValue('div.row:nth-child(1) input[type=text]', '')
                         ->assertSeeIn('div.row:nth-child(2) label', 'Last name')
                         ->assertValue('div.row:nth-child(2) input[type=text]', '')
                         ->assertSeeIn('div.row:nth-child(3) label', 'Email')
                         ->assertValue('div.row:nth-child(3) input[type=text]', '')
                         ->assertEnabled('div.row:nth-child(3) input[type=text]')
                         ->assertSeeIn('div.row:nth-child(4) label', 'Email aliases')
                         ->assertVisible('div.row:nth-child(4) .listinput-widget')
                         ->with(new ListInput('#aliases'), function (Browser $browser) {
                             $browser->assertListInputValue([])
                                 ->assertValue('@input', '');
                         })
                         ->assertSeeIn('div.row:nth-child(5) label', 'Password')
                         ->assertValue('div.row:nth-child(5) input[type=password]', '')
                         ->assertSeeIn('div.row:nth-child(6) label', 'Confirm password')
                         ->assertValue('div.row:nth-child(6) input[type=password]', '')
                         ->assertSeeIn('button[type=submit]', 'Submit');
 
                     // Test browser-side required fields and error handling
                     $browser->click('button[type=submit]')
                         ->assertFocused('#email')
                         ->type('#email', 'invalid email')
                         ->click('button[type=submit]')
                         ->assertFocused('#password')
                         ->type('#password', 'simple123')
                         ->click('button[type=submit]')
                         ->assertFocused('#password_confirmation')
                         ->type('#password_confirmation', 'simple')
                         ->click('button[type=submit]');
                 })
                 ->with(new Toast(Toast::TYPE_ERROR), function (Browser $browser) {
                     $browser->assertToastTitle('Error')
                         ->assertToastMessage('Form validation error')
                         ->closeToast();
                 })
                 ->with('@form', function (Browser $browser) {
                     $browser->assertSeeIn('#email + .invalid-feedback', 'The specified email is invalid.')
                         ->assertSeeIn('#password + .invalid-feedback', 'The password confirmation does not match.');
                 });
 
             // Test form error handling (aliases)
             $browser->with('@form', function (Browser $browser) {
                 $browser->type('#email', 'julia.roberts@kolab.org')
                     ->type('#password_confirmation', 'simple123')
                     ->with(new ListInput('#aliases'), function (Browser $browser) {
                         $browser->addListEntry('invalid address');
                     })
                     ->click('button[type=submit]');
             })
             ->with(new Toast(Toast::TYPE_ERROR), function (Browser $browser) {
                 $browser->assertToastTitle('Error')
                     ->assertToastMessage('Form validation error')
                     ->closeToast();
             })
             ->with('@form', function (Browser $browser) {
                 $browser->with(new ListInput('#aliases'), function (Browser $browser) {
                     $browser->assertFormError(1, 'The specified alias is invalid.', false);
                 });
             });
 
             // Successful account creation
             $browser->with('@form', function (Browser $browser) {
                 $browser->with(new ListInput('#aliases'), function (Browser $browser) {
                     $browser->removeListEntry(1)
                         ->addListEntry('julia.roberts2@kolab.org');
                 })
                     ->click('button[type=submit]');
             })
             ->with(new Toast(Toast::TYPE_SUCCESS), function (Browser $browser) {
                 $browser->assertToastTitle('')
                     ->assertToastMessage('User created successfully')
                     ->closeToast();
             })
             // check redirection to users list
             ->waitForLocation('/users')
             ->on(new UserList())
                 ->whenAvailable('@table', function (Browser $browser) {
 // TODO: This will not work until we handle entitlements on user creation
 //                    $browser->assertElementsCount('tbody tr', 3)
 //                        ->assertSeeIn('tbody tr:nth-child(3) a', 'julia.roberts@kolab.org');
                 });
 
             $julia = User::where('email', 'julia.roberts@kolab.org')->first();
             $alias = UserAlias::where('user_id', $julia->id)->where('alias', 'julia.roberts2@kolab.org')->first();
             $this->assertTrue(!empty($alias));
         });
     }
 
     /**
      * Test user delete
      *
      * @depends testNewUser
      */
     public function testDeleteUser(): void
     {
         // First create a new user
         $john = $this->getTestUser('john@kolab.org');
         $julia = $this->getTestUser('julia.roberts@kolab.org');
         $package_kolab = \App\Package::where('title', 'kolab')->first();
         $john->assignPackage($package_kolab, $julia);
 
         // Test deleting non-controller user
         $this->browse(function (Browser $browser) {
             $browser->visit(new UserList())
                 ->whenAvailable('@table', function (Browser $browser) {
                     $browser->assertElementsCount('tbody tr', 4)
                         ->assertSeeIn('tbody tr:nth-child(3) a', 'julia.roberts@kolab.org')
                         ->click('tbody tr:nth-child(3) button.button-delete');
                 })
                 ->with(new Dialog('#delete-warning'), function (Browser $browser) {
                     $browser->assertSeeIn('@title', 'Delete julia.roberts@kolab.org')
                         ->assertFocused('@button-cancel')
                         ->assertSeeIn('@button-cancel', 'Cancel')
                         ->assertSeeIn('@button-action', 'Delete')
                         ->click('@button-cancel');
                 })
                 ->whenAvailable('@table', function (Browser $browser) {
                     $browser->click('tbody tr:nth-child(3) button.button-delete');
                 })
                 ->with(new Dialog('#delete-warning'), function (Browser $browser) {
                     $browser->click('@button-action');
                 })
                 ->with(new Toast(Toast::TYPE_SUCCESS), function (Browser $browser) {
                     $browser->assertToastTitle('')
                         ->assertToastMessage('User deleted successfully')
                         ->closeToast();
                 })
                 ->with('@table', function (Browser $browser) {
                     $browser->assertElementsCount('tbody tr', 3)
                         ->assertSeeIn('tbody tr:nth-child(1) a', 'jack@kolab.org')
                         ->assertSeeIn('tbody tr:nth-child(2) a', 'john@kolab.org')
                         ->assertSeeIn('tbody tr:nth-child(3) a', 'ned@kolab.org');
                 });
 
             $julia = User::where('email', 'julia.roberts@kolab.org')->first();
             $this->assertTrue(empty($julia));
 
             // Test clicking Delete on the controller record redirects to /profile/delete
             $browser
                 ->with('@table', function (Browser $browser) {
                     $browser->click('tbody tr:nth-child(2) button.button-delete');
                 })
                 ->waitForLocation('/profile/delete');
         });
 
         // Test that non-controller user cannot see/delete himself on the users list
         // Note: Access to /profile/delete page is tested in UserProfileTest.php
         $this->browse(function (Browser $browser) {
             $browser->visit('/logout')
                 ->on(new Home())
                 ->submitLogon('jack@kolab.org', 'simple123', true)
                 ->visit(new UserList())
                 ->whenAvailable('@table', function (Browser $browser) {
                     $browser->assertElementsCount('tbody tr', 0);
                 });
         });
 
         // Test that controller user (Ned) can see/delete all the users ???
         $this->browse(function (Browser $browser) {
             $browser->visit('/logout')
                 ->on(new Home())
                 ->submitLogon('ned@kolab.org', 'simple123', true)
                 ->visit(new UserList())
                 ->whenAvailable('@table', function (Browser $browser) {
                     $browser->assertElementsCount('tbody tr', 3)
                         ->assertElementsCount('tbody button.button-delete', 3);
                 });
 
                 // TODO: Test the delete action in details
         });
 
         // TODO: Test what happens with the logged in user session after he's been deleted by another user
     }
 }
diff --git a/src/tests/CreatesApplication.php b/src/tests/CreatesApplication.php
deleted file mode 100644
index ab924025..00000000
--- a/src/tests/CreatesApplication.php
+++ /dev/null
@@ -1,22 +0,0 @@
-<?php
-
-namespace Tests;
-
-use Illuminate\Contracts\Console\Kernel;
-
-trait CreatesApplication
-{
-    /**
-     * Creates the application.
-     *
-     * @return \Illuminate\Foundation\Application
-     */
-    public function createApplication()
-    {
-        $app = require __DIR__ . '/../bootstrap/app.php';
-
-        $app->make(Kernel::class)->bootstrap();
-
-        return $app;
-    }
-}
diff --git a/src/tests/TestCase.php b/src/tests/TestCase.php
index a160fb5e..f250a76e 100644
--- a/src/tests/TestCase.php
+++ b/src/tests/TestCase.php
@@ -1,116 +1,19 @@
 <?php
 
 namespace Tests;
 
-use App\Domain;
-use App\User;
 use Illuminate\Foundation\Testing\TestCase as BaseTestCase;
-use Illuminate\Support\Facades\Queue;
 
 abstract class TestCase extends BaseTestCase
 {
-    use CreatesApplication;
+    use TestCaseTrait;
 
     protected function backdateEntitlements($entitlements, $targetDate)
     {
         foreach ($entitlements as $entitlement) {
             $entitlement->created_at = $targetDate;
             $entitlement->updated_at = $targetDate;
             $entitlement->save();
         }
     }
-
-    protected function deleteTestDomain($name)
-    {
-        Queue::fake();
-
-        $domain = Domain::withTrashed()->where('namespace', $name)->first();
-
-        if (!$domain) {
-            return;
-        }
-
-        $job = new \App\Jobs\DomainDelete($domain->id);
-        $job->handle();
-
-        $domain->forceDelete();
-    }
-
-    protected function deleteTestUser($email)
-    {
-        Queue::fake();
-
-        $user = User::withTrashed()->where('email', $email)->first();
-
-        if (!$user) {
-            return;
-        }
-
-        $job = new \App\Jobs\UserDelete($user->id);
-        $job->handle();
-
-        $user->forceDelete();
-    }
-
-    /**
-     * Get Domain object by namespace, create it if needed.
-     * Skip LDAP jobs.
-     */
-    protected function getTestDomain($name, $attrib = [])
-    {
-        // Disable jobs (i.e. skip LDAP oprations)
-        Queue::fake();
-        return Domain::firstOrCreate(['namespace' => $name], $attrib);
-    }
-
-    /**
-     * Get User object by email, create it if needed.
-     * Skip LDAP jobs.
-     */
-    protected function getTestUser($email, $attrib = [])
-    {
-        // Disable jobs (i.e. skip LDAP oprations)
-        Queue::fake();
-        $user = User::withTrashed()->where('email', $email)->first();
-
-        if (!$user) {
-            return User::firstOrCreate(['email' => $email], $attrib);
-        }
-
-        if ($user->deleted_at) {
-            $user->restore();
-        }
-
-        return $user;
-    }
-
-    /**
-     * Helper to access protected property of an object
-     */
-    protected static function getObjectProperty($object, $property_name)
-    {
-        $reflection = new \ReflectionClass($object);
-        $property = $reflection->getProperty($property_name);
-        $property->setAccessible(true);
-
-        return $property->getValue($object);
-    }
-
-    /**
-     * Call protected/private method of a class.
-     *
-     * @param object $object     Instantiated object that we will run method on.
-     * @param string $methodName Method name to call
-     * @param array  $parameters Array of parameters to pass into method.
-     *
-     * @return mixed Method return.
-     */
-    public function invokeMethod($object, $methodName, array $parameters = array())
-    {
-        $reflection = new \ReflectionClass(get_class($object));
-        $method = $reflection->getMethod($methodName);
-        $method->setAccessible(true);
-
-        return $method->invokeArgs($object, $parameters);
-    }
 }
diff --git a/src/tests/DuskTestCase.php b/src/tests/TestCaseDusk.php
similarity index 65%
rename from src/tests/DuskTestCase.php
rename to src/tests/TestCaseDusk.php
index 9192d0f4..6dac26c9 100644
--- a/src/tests/DuskTestCase.php
+++ b/src/tests/TestCaseDusk.php
@@ -1,142 +1,88 @@
 <?php
 
 namespace Tests;
 
-use App\Domain;
-use App\User;
 use Facebook\WebDriver\Chrome\ChromeOptions;
 use Facebook\WebDriver\Remote\RemoteWebDriver;
 use Facebook\WebDriver\Remote\DesiredCapabilities;
-use Illuminate\Support\Facades\Queue;
 use Laravel\Dusk\TestCase as BaseTestCase;
 
-abstract class DuskTestCase extends BaseTestCase
+abstract class TestCaseDusk extends BaseTestCase
 {
-    use CreatesApplication;
-
-    protected function deleteTestDomain($name)
-    {
-        Queue::fake();
-        $domain = Domain::withTrashed()->where('namespace', $name)->first();
-        if (!$domain) {
-            return;
-        }
-
-        $job = new \App\Jobs\DomainDelete($domain->id);
-        $job->handle();
-
-        $domain->forceDelete();
-    }
-
-    protected function deleteTestUser($email)
-    {
-        Queue::fake();
-        $user = User::withTrashed()->where('email', $email)->first();
-
-        if (!$user) {
-            return;
-        }
-
-        $job = new \App\Jobs\UserDelete($user->id);
-        $job->handle();
-
-        $user->forceDelete();
-    }
-
-    /**
-     * Get Domain object by namespace, create it if needed.
-     * Skip LDAP jobs.
-     */
-    protected function getTestDomain($name, $attrib = [])
-    {
-        // Disable jobs (i.e. skip LDAP oprations)
-        Queue::fake();
-        return Domain::firstOrCreate(['namespace' => $name], $attrib);
-    }
-
-    /**
-     * Get User object by email, create it if needed.
-     * Skip LDAP jobs.
-     */
-    protected function getTestUser($email, $attrib = [])
-    {
-        // Disable jobs (i.e. skip LDAP oprations)
-        Queue::fake();
-        return User::firstOrCreate(['email' => $email], $attrib);
-    }
+    use TestCaseTrait;
 
     /**
      * Prepare for Dusk test execution.
      *
      * @beforeClass
      * @return void
      */
     public static function prepare()
     {
         static::startChromeDriver();
     }
 
     /**
      * Create the RemoteWebDriver instance.
      *
      * @return \Facebook\WebDriver\Remote\RemoteWebDriver
      */
     protected function driver()
     {
         $options = (new ChromeOptions())->addArguments([
             '--lang=en_US',
             '--disable-gpu',
             '--headless',
             '--window-size=1280,720',
         ]);
 
         // For file download handling
         $prefs = [
             'profile.default_content_settings.popups' => 0,
             'download.default_directory' => __DIR__ . '/Browser/downloads',
         ];
 
         $options->setExperimentalOption('prefs', $prefs);
 
         if (getenv('TESTS_MODE') == 'phone') {
             // Fake User-Agent string for mobile mode
             $ua = 'Mozilla/5.0 (Linux; Android 4.0.4; Galaxy Nexus Build/IMM76B) AppleWebKit/537.36'
                 . ' (KHTML, like Gecko) Chrome/60.0.3112.90 Mobile Safari/537.36';
             $options->setExperimentalOption('mobileEmulation', ['userAgent' => $ua]);
             $options->addArguments(['--window-size=375,667']);
         } elseif (getenv('TESTS_MODE') == 'tablet') {
             // Fake User-Agent string for mobile mode
             $ua = 'Mozilla/5.0 (Linux; Android 6.0.1; vivo 1603 Build/MMB29M) AppleWebKit/537.36 '
                 . ' (KHTML, like Gecko) Chrome/58.0.3029.83 Mobile Safari/537.36';
             $options->setExperimentalOption('mobileEmulation', ['userAgent' => $ua]);
             $options->addArguments(['--window-size=800,640']);
         } else {
             $options->addArguments(['--window-size=1280,720']);
         }
 
         // Make sure downloads dir exists and is empty
         if (!file_exists(__DIR__ . '/Browser/downloads')) {
             mkdir(__DIR__ . '/Browser/downloads', 0777, true);
         } else {
             foreach (glob(__DIR__ . '/Browser/downloads/*') as $file) {
                 @unlink($file);
             }
         }
 
         return RemoteWebDriver::create(
             'http://localhost:9515',
             DesiredCapabilities::chrome()->setCapability(
                 ChromeOptions::CAPABILITY,
                 $options
             )
         );
     }
 
     /**
      * Replace Dusk's Browser with our (extended) Browser
      */
     protected function newBrowser($driver)
     {
         return new Browser($driver);
     }
 }
diff --git a/src/tests/TestCase.php b/src/tests/TestCaseTrait.php
similarity index 86%
copy from src/tests/TestCase.php
copy to src/tests/TestCaseTrait.php
index a160fb5e..12b20f74 100644
--- a/src/tests/TestCase.php
+++ b/src/tests/TestCaseTrait.php
@@ -1,116 +1,119 @@
 <?php
 
 namespace Tests;
 
 use App\Domain;
 use App\User;
-use Illuminate\Foundation\Testing\TestCase as BaseTestCase;
+use Illuminate\Contracts\Console\Kernel;
 use Illuminate\Support\Facades\Queue;
 
-abstract class TestCase extends BaseTestCase
+trait TestCaseTrait
 {
-    use CreatesApplication;
-
-    protected function backdateEntitlements($entitlements, $targetDate)
+    /**
+     * Creates the application.
+     *
+     * @return \Illuminate\Foundation\Application
+     */
+    public function createApplication()
     {
-        foreach ($entitlements as $entitlement) {
-            $entitlement->created_at = $targetDate;
-            $entitlement->updated_at = $targetDate;
-            $entitlement->save();
-        }
+        $app = require __DIR__ . '/../bootstrap/app.php';
+
+        $app->make(Kernel::class)->bootstrap();
+
+        return $app;
     }
 
     protected function deleteTestDomain($name)
     {
         Queue::fake();
 
         $domain = Domain::withTrashed()->where('namespace', $name)->first();
 
         if (!$domain) {
             return;
         }
 
         $job = new \App\Jobs\DomainDelete($domain->id);
         $job->handle();
 
         $domain->forceDelete();
     }
 
     protected function deleteTestUser($email)
     {
         Queue::fake();
 
         $user = User::withTrashed()->where('email', $email)->first();
 
         if (!$user) {
             return;
         }
 
         $job = new \App\Jobs\UserDelete($user->id);
         $job->handle();
 
         $user->forceDelete();
     }
 
     /**
      * Get Domain object by namespace, create it if needed.
      * Skip LDAP jobs.
      */
     protected function getTestDomain($name, $attrib = [])
     {
         // Disable jobs (i.e. skip LDAP oprations)
         Queue::fake();
         return Domain::firstOrCreate(['namespace' => $name], $attrib);
     }
 
     /**
      * Get User object by email, create it if needed.
      * Skip LDAP jobs.
      */
     protected function getTestUser($email, $attrib = [])
     {
         // Disable jobs (i.e. skip LDAP oprations)
         Queue::fake();
         $user = User::withTrashed()->where('email', $email)->first();
 
         if (!$user) {
             return User::firstOrCreate(['email' => $email], $attrib);
         }
 
         if ($user->deleted_at) {
             $user->restore();
         }
 
         return $user;
     }
 
     /**
      * Helper to access protected property of an object
      */
     protected static function getObjectProperty($object, $property_name)
     {
         $reflection = new \ReflectionClass($object);
         $property = $reflection->getProperty($property_name);
         $property->setAccessible(true);
 
         return $property->getValue($object);
     }
 
     /**
      * Call protected/private method of a class.
      *
      * @param object $object     Instantiated object that we will run method on.
      * @param string $methodName Method name to call
      * @param array  $parameters Array of parameters to pass into method.
      *
      * @return mixed Method return.
      */
     public function invokeMethod($object, $methodName, array $parameters = array())
     {
         $reflection = new \ReflectionClass(get_class($object));
         $method = $reflection->getMethod($methodName);
         $method->setAccessible(true);
 
         return $method->invokeArgs($object, $parameters);
     }
 }