diff --git a/src/resources/sass/app.scss b/src/resources/sass/app.scss
index c96e1d4d..9b3d3b21 100644
--- a/src/resources/sass/app.scss
+++ b/src/resources/sass/app.scss
@@ -1,164 +1,166 @@
 // Fonts
 
 // Variables
 @import 'variables';
 
 // Bootstrap
 @import '~bootstrap/scss/bootstrap';
 
 // Toastr
 @import '~@deveodk/vue-toastr/dist/@deveodk/vue-toastr.css';
 
 // Fixes Toastr incompatibility with Bootstrap
 .toast-container > .toast {
     opacity: 1;
 }
 
 @import 'menu';
 
 nav + .container {
     margin-top: 120px;
 }
 
 #app {
     margin-bottom: 2rem;
 }
 
 #error-page {
     position: absolute;
     top: 0;
     height: 100%;
     width: 100%;
     align-items: center;
     display: flex;
     justify-content: center;
     color: #636b6f;
     z-index: 10;
     background: white;
 
     .code {
         text-align: right;
         border-right: 2px solid;
         font-size: 26px;
         padding: 0 15px;
     }
 
     .message {
         font-size: 18px;
         padding: 0 15px;
     }
 }
 
 .app-loader {
     background-color: $body-bg;
     height: 100%;
     width: 100%;
     position: absolute;
     top: 0;
     left: 0;
     display: flex;
     align-items: center;
     justify-content: center;
 
     .spinner-border {
         width: 120px;
         height: 120px;
         border-width: 15px;
         color: #b2aa99;
     }
 }
 
 pre {
     margin: 1rem 0;
     padding: 1rem;
     background-color: $menu-bg-color;
 }
 
 .card-title {
     font-size: 1.2rem;
     font-weight: bold;
 }
 
 .listinput {
     display: none;
 }
 
 .listinput-widget {
     & > div {
         &:not(:last-child) {
             margin-bottom: -1px;
 
             input,
             a.btn {
                 border-bottom-right-radius: 0;
                 border-bottom-left-radius: 0;
             }
         }
 
         &:not(:first-child) {
             input,
             a.btn {
                 border-top-right-radius: 0;
                 border-top-left-radius: 0;
             }
         }
     }
 }
 
 .range-input {
     display: flex;
 
     label {
         margin-right: 0.5em;
     }
 }
 
 table.form-list {
     td {
         border: 0;
 
         &:first-child {
             padding-left: 0;
         }
 
         &:last-child {
             padding-right: 0;
         }
     }
+}
 
-    .buttons,
-    .price,
-    .selection {
+table {
+    td.buttons,
+    td.price,
+    td.selection {
         width: 1%;
     }
 
-    .price {
+    td.price {
         text-align: right;
     }
 }
 
 #dashboard-nav {
     display: flex;
     flex-wrap: wrap;
     justify-content: center;
     margin-top: 1rem;
 
     & > a {
         padding: 1rem;
         text-align: center;
         white-space: nowrap;
         margin: 0 0.5rem 0.5rem 0;
         text-decoration: none;
         min-width: 8rem;
 
         &.disabled {
             pointer-events: none;
             opacity: 0.6;
         }
     }
 
     svg {
         width: 6rem;
         height: 6rem;
     }
 }
diff --git a/src/resources/vue/Dashboard.vue b/src/resources/vue/Dashboard.vue
index 47c11d7f..b91f188e 100644
--- a/src/resources/vue/Dashboard.vue
+++ b/src/resources/vue/Dashboard.vue
@@ -1,96 +1,88 @@
 <template>
     <div class="container" dusk="dashboard-component">
         <div v-if="!$root.isLoading" id="status-box" class="card">
             <div class="card-body">
                 <div class="card-title">Status</div>
                 <div class="card-text">
                     <ul style="list-style: none; padding: 0;">
                         <li v-for="item in statusProcess" :key="item.label">
                             <span v-if="item.state">&check;</span><span v-else>&cir;</span>
                             <router-link v-if="item.link" :to="{ path: item.link }">{{ item.title }}</router-link>
                             <span v-if="!item.link">{{ item.title }}</span>
                         </li>
                     </ul>
                 </div>
             </div>
         </div>
         <div id="dashboard-nav">
             <router-link class="card link-profile" :to="{ name: 'profile' }">
                 <svg-icon icon="user-cog"></svg-icon><span class="name">Your profile</span>
             </router-link>
             <router-link class="card link-domains" :to="{ name: 'domains' }">
                 <svg-icon icon="globe"></svg-icon><span class="name">Domains</span>
             </router-link>
             <router-link class="card link-users" :to="{ name: 'users' }">
                 <svg-icon icon="users"></svg-icon><span class="name">User accounts</span>
             </router-link>
             <router-link class="card link-wallet disabled" :to="{ name: 'users' }">
                 <svg-icon icon="wallet"></svg-icon><span class="name">Wallet</span>
             </router-link>
         </div>
-        <div v-if="false && !$root.isLoading" id="dashboard-box" class="card">
-            <div class="card-body">
-                <div class="card-title">Dashboard</div>
-                <div class="card-text">
-                    <pre>{{ data }}</pre>
-                </div>
-            </div>
-        </div>
     </div>
 </template>
 
 <script>
     export default {
         data() {
             return {
-                data: {},
-                statusProcess: []
+                statusProcess: [],
+                request: null
             }
         },
         mounted() {
             const authInfo = this.$store.state.isLoggedIn ? this.$store.state.authInfo : null
 
+            clearTimeout(window.infoRequest)
+
             if (authInfo) {
-                this.data = authInfo
                 this.parseStatusInfo(authInfo.statusInfo)
             } else {
                 this.$root.startLoading()
                 axios.get('/api/auth/info')
                     .then(response => {
-                        this.data = response.data
                         this.$store.state.authInfo = response.data
                         this.parseStatusInfo(response.data.statusInfo)
                         this.$root.stopLoading()
                     })
                     .catch(this.$root.errorHandler)
             }
         },
         methods: {
             // Displays account status information
             parseStatusInfo(info) {
                 this.statusProcess = info.process
 
                 // Update status process info every 10 seconds
                 // FIXME: This probably should have some limit, or the interval
                 //        should grow (well, until it could be done with websocket notifications)
                 if (info.status != 'active') {
-                    setTimeout(() => {
+                    window.infoRequest = setTimeout(() => {
                         // Stop updates after user logged out
                         if (!this.$store.state.isLoggedIn) {
                             return;
                         }
 
                         axios.get('/api/auth/info')
                             .then(response => {
                                 this.$store.state.authInfo = response.data
                                 this.parseStatusInfo(response.data.statusInfo)
                             })
                             .catch(error => {
                                 this.parseStatusInfo(info)
                             })
                     }, 10000);
                 }
             }
         }
     }
 </script>
diff --git a/src/resources/vue/Domain/List.vue b/src/resources/vue/Domain/List.vue
index 1be8c849..c7a3327e 100644
--- a/src/resources/vue/Domain/List.vue
+++ b/src/resources/vue/Domain/List.vue
@@ -1,42 +1,42 @@
 <template>
     <div class="container">
         <div class="card" id="domain-list">
             <div class="card-body">
                 <div class="card-title">Domains</div>
                 <div class="card-text">
-                    <table class="table table-hover">
+                    <table class="table table-sm table-hover">
                         <thead class="thead-light">
                             <tr>
                                 <th scope="col">Name</th>
                                 <th scope="col"></th>
                             </tr>
                         </thead>
                         <tbody>
                             <tr v-for="domain in domains" :key="domain.id">
                                 <td><router-link :to="{ path: 'domain/' + domain.id }">{{ domain.namespace }}</router-link></td>
-                                <td></td>
+                                <td class="buttons"></td>
                             </tr>
                         </tbody>
                     </table>
                 </div>
             </div>
         </div>
     </div>
 </template>
 
 <script>
     export default {
         data() {
             return {
                 domains: []
             }
         },
         created() {
             axios.get('/api/v4/domains')
                 .then(response => {
                     this.domains = response.data
                 })
                 .catch(this.$root.errorHandler)
         }
     }
 </script>
diff --git a/src/resources/vue/Menu.vue b/src/resources/vue/Menu.vue
index 7372aa66..56cc648a 100644
--- a/src/resources/vue/Menu.vue
+++ b/src/resources/vue/Menu.vue
@@ -1,60 +1,62 @@
 <template>
     <nav id="primary-menu" class="navbar navbar-expand-lg navbar-light fixed-top">
         <div class="container">
-            <a :href="app_url" class="navbar-brand" :title="app_name"><img src="/images/logo_header.png" :alt="app_name"></a>
+            <router-link class="navbar-brand" :to="{ name: 'dashboard' }">
+                <img src="/images/logo_header.png" :alt="app_name">
+            </router-link>
             <button class="navbar-toggler" type="button" data-toggle="collapse" data-target="#navbar" aria-controls="navbar" aria-expanded="false" aria-label="Toggle navigation">
                 <span class="navbar-toggler-icon"></span>
             </button>
             <div id="navbar" class="collapse navbar-collapse justify-content-end">
                 <ul class="navbar-nav">
                     <li class="nav-item" v-if="!logged_in">
                         <router-link class="nav-link link-signup" active-class="active" :to="{name: 'signup'}">Signup</router-link>
                     </li>
                     <li class="nav-item" v-if="!logged_in">
                         <a class="nav-link link-explore" href="https://kolabnow.com">Explore</a>
                     </li>
                     <li class="nav-item" v-if="!logged_in">
                         <a class="nav-link link-blog" href="https://blogs.kolabnow.com">Blog</a>
                     </li>
                     <li class="nav-item">
                         <a class="nav-link link-support" href="https://kolabnow.com/support">Support</a>
                     </li>
                     <li class="nav-item" v-if="logged_in">
                         <a class="nav-link link-contact" href="https://kolabnow.com/contact">Contact</a>
                     </li>
                     <li class="nav-item" v-if="logged_in">
                         <a class="nav-link menulogin link-webmail" href="https://kolabnow.com/apps" target="_blank">Webmail</a>
                     </li>
                     <li class="nav-item" v-if="logged_in">
                         <router-link class="nav-link menulogin link-logout" active-class="active" :to="{name: 'logout'}">Logout</router-link>
                     </li>
                     <li class="nav-item" v-if="!logged_in && route == 'login'">
                         <a class="nav-link menulogin link-webmail" href="https://kolabnow.com/apps" target="_blank">Webmail</a>
                     </li>
                     <li class="nav-item" v-if="!logged_in && (!route || route == 'signup')">
                         <router-link class="nav-link menulogin link-login" active-class="active" :to="{name: 'login'}">Login</router-link>
                     </li>
                 </ul>
             </div>
         </div>
     </nav>
 </template>
 
 <script>
     export default {
         data() {
             return {
                 app_name: window.config['app.name'],
                 app_url: window.config['app.url'],
             }
         },
         computed: {
             logged_in() { return this.$store.state.isLoggedIn },
             route() { return this.$route.name }
         },
         mounted() {
             // On mobile close the menu when the menu item is clicked
             $('#navbar').on('click', function() { $(this).removeClass('show') })
         }
     }
 </script>
diff --git a/src/resources/vue/User/List.vue b/src/resources/vue/User/List.vue
index fba770e9..4ff2990d 100644
--- a/src/resources/vue/User/List.vue
+++ b/src/resources/vue/User/List.vue
@@ -1,115 +1,123 @@
 <template>
     <div class="container">
         <div class="card" id="user-list">
             <div class="card-body">
                 <div class="card-title">User Accounts</div>
                 <div class="card-text">
-                    <router-link class="btn btn-primary create-user" :to="{ path: 'user/new' }" tag="button">
-                        <svg-icon icon="user"></svg-icon> Create user
-                    </router-link>
-                    <table class="table table-hover">
+                    <p>
+                        <router-link class="btn btn-primary create-user" :to="{ path: 'user/new' }" tag="button">
+                            <svg-icon icon="user"></svg-icon> Create user
+                        </router-link>
+                    </p>
+                    <table class="table table-sm table-hover">
                         <thead class="thead-light">
                             <tr>
                                 <th scope="col">Primary Email</th>
                                 <th scope="col"></th>
                             </tr>
                         </thead>
                         <tbody>
                             <tr v-for="user in users" :id="'user' + user.id" :key="user.id">
                                 <td>
                                     <router-link :to="{ path: 'user/' + user.id }">{{ user.email }}</router-link>
                                 </td>
-                                <td>
-                                    <button v-if="$root.isController(user.wallet_id)" class="btn btn-danger button-delete" @click="deleteUser(user.id)">Delete</button>
+                                <td class="buttons">
+                                    <button v-if="$root.isController(user.wallet_id)"
+                                            title="Delete"
+                                            class="btn btn-link text-danger button-delete p-0"
+                                            @click="deleteUser(user.id)"
+                                    >
+                                        <svg-icon icon="trash-alt"></svg-icon><span class="sr-only">Delete</span>
+                                    </button>
                                 </td>
                             </tr>
                         </tbody>
                     </table>
                 </div>
             </div>
         </div>
 
         <div id="delete-warning" class="modal" tabindex="-1" role="dialog">
             <div class="modal-dialog" role="document">
                 <div class="modal-content">
                     <div class="modal-header">
                         <h5 class="modal-title"></h5>
                         <button type="button" class="close" data-dismiss="modal" aria-label="Close">
                             <span aria-hidden="true">&times;</span>
                         </button>
                     </div>
                     <div class="modal-body">
                         <p>Do you really want to delete this user permanently?
                             This will delete all account data and withdraw the permission to access the email account.
                             Please note that this action cannot be undone.</p>
                     </div>
                     <div class="modal-footer">
                         <button type="button" class="btn btn-secondary modal-cancel" data-dismiss="modal">Cancel</button>
                         <button type="button" class="btn btn-danger modal-action" @click="deleteUser()">
                             <svg-icon icon="trash-alt"></svg-icon> Delete
                         </button>
                     </div>
                 </div>
             </div>
         </div>
     </div>
 </template>
 
 <script>
     export default {
         data() {
             return {
                 users: [],
                 current_user: null
             }
         },
         created() {
             axios.get('/api/v4/users')
                 .then(response => {
                     this.users = response.data
                 })
                 .catch(this.$root.errorHandler)
         },
         methods: {
             deleteUser(id) {
                 let dialog = $('#delete-warning').modal('hide')
 
                 // Delete the user from the confirm dialog
                 if (!id && this.current_user) {
                     id = this.current_user.id
                     axios.delete('/api/v4/users/' + id)
                         .then(response => {
                             if (response.data.status == 'success') {
                                 this.$toastr('success', response.data.message)
                                 $('#user' + id).remove()
                             }
                         })
 
                     return
                 }
 
 
                 // Deleting self, redirect to /profile/delete page
                 if (id == this.$store.state.authInfo.id) {
                     this.$router.push({ name: 'profile-delete' })
                     return
                 }
 
                 // Display the warning
                 if (this.current_user = this.getUser(id)) {
                     dialog.find('.modal-title').text('Delete ' + this.current_user.email)
                     dialog.on('shown.bs.modal', () => {
                         dialog.find('button.modal-cancel').focus()
                     }).modal()
                 }
             },
             getUser(id) {
                 for (let i = 0; i < this.users.length; i++) {
                     if (this.users[i].id == id) {
                         return this.users[i]
                     }
                 }
             }
         }
     }
 </script>
diff --git a/src/tests/Browser/LogonTest.php b/src/tests/Browser/LogonTest.php
index 4d14d920..35d30b74 100644
--- a/src/tests/Browser/LogonTest.php
+++ b/src/tests/Browser/LogonTest.php
@@ -1,160 +1,158 @@
 <?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\TestCaseDusk;
 use Illuminate\Foundation\Testing\DatabaseMigrations;
 
 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');
+            $browser->on(new Dashboard())
+                ->within(new Menu(), function ($browser) {
+                    $browser->assertMenuItems(['support', 'contact', 'webmail', 'logout']);
+                })
+                ->assertUser('john@kolab.org');
 
             // 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/Pages/Dashboard.php b/src/tests/Browser/Pages/Dashboard.php
index 37aad89c..feb95dc3 100644
--- a/src/tests/Browser/Pages/Dashboard.php
+++ b/src/tests/Browser/Pages/Dashboard.php
@@ -1,45 +1,56 @@
 <?php
 
 namespace Tests\Browser\Pages;
 
 use Laravel\Dusk\Page;
 
 class Dashboard extends Page
 {
     /**
      * Get the URL for the page.
      *
      * @return string
      */
     public function url()
     {
         return '/dashboard';
     }
 
     /**
      * Assert that the browser is on the page.
      *
      * @param \Laravel\Dusk\Browser $browser The browser object
      *
      * @return void
      */
     public function assert($browser)
     {
         $browser->assertPathIs('/dashboard')
             ->waitUntilMissing('@app .app-loader')
             ->assertVisible('@links');
     }
 
+    /**
+     * Assert logged-in user
+     *
+     * @param \Laravel\Dusk\Browser $browser The browser object
+     * @param string                $user    User email
+     */
+    public function assertUser($browser, $user)
+    {
+        $browser->assertVue('$store.state.authInfo.email', $user, '@dashboard-component');
+    }
+
     /**
      * Get the element shortcuts for the page.
      *
      * @return array
      */
     public function elements()
     {
         return [
             '@app' => '#app',
             '@links' => '#dashboard-nav',
         ];
     }
 }
diff --git a/src/tests/Browser/SignupTest.php b/src/tests/Browser/SignupTest.php
index 7ce95e83..a989a904 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\TestCaseDusk;
 use Illuminate\Foundation\Testing\DatabaseMigrations;
 
 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');
+                ->assertUser('signuptestdusk@' . \config('app.domain'));
 
             // 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');
+                ->assertUser('admin@user-domain-signup.com');
 
             $browser->click('a.link-logout');
         });
     }
 }