diff --git a/src/app/Http/Controllers/API/DomainsController.php b/src/app/Http/Controllers/API/DomainsController.php
index 6fbda15a..7ffa894e 100644
--- a/src/app/Http/Controllers/API/DomainsController.php
+++ b/src/app/Http/Controllers/API/DomainsController.php
@@ -1,279 +1,280 @@
 <?php
 
 namespace App\Http\Controllers\API;
 
 use App\Domain;
 use App\Http\Controllers\Controller;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\Auth;
 
 class DomainsController extends Controller
 {
     /**
      * Return a list of domains owned by the current user
      *
      * @return \Illuminate\Http\JsonResponse
      */
     public function index()
     {
         $user = Auth::guard()->user();
         $list = [];
 
         foreach ($user->domains() as $domain) {
             if (!$domain->isPublic()) {
                 $data = $domain->toArray();
                 $data = array_merge($data, self::domainStatuses($domain));
                 $list[] = $data;
             }
         }
 
         return response()->json($list);
     }
 
     /**
      * Show the form for creating a new resource.
      *
      * @return \Illuminate\Http\JsonResponse
      */
     public function create()
     {
         //
     }
 
     /**
      * Confirm ownership of the specified domain (via DNS check).
      *
      * @param int $id Domain identifier
      *
      * @return \Illuminate\Http\JsonResponse|void
      */
     public function confirm($id)
     {
         $domain = Domain::findOrFail($id);
 
         // Only owner (or admin) has access to the domain
         if (!Auth::guard()->user()->canRead($domain)) {
             return $this->errorResponse(403);
         }
 
         if (!$domain->confirm()) {
+            // TODO: This should include an error message to display to the user
             return response()->json(['status' => 'error']);
         }
 
         return response()->json([
                 'status' => 'success',
                 'statusInfo' => self::statusInfo($domain),
                 'message' => __('app.domain-verify-success'),
         ]);
     }
 
     /**
      * Remove the specified resource from storage.
      *
      * @param int $id
      *
      * @return \Illuminate\Http\JsonResponse
      */
     public function destroy($id)
     {
         //
     }
 
     /**
      * Show the form for editing the specified resource.
      *
      * @param int $id
      *
      * @return \Illuminate\Http\Response
      */
     public function edit($id)
     {
         //
     }
 
     /**
      * Store a newly created resource in storage.
      *
      * @param \Illuminate\Http\Request $request
      *
      * @return \Illuminate\Http\Response
      */
     public function store(Request $request)
     {
         //
     }
 
     /**
      * Get the information about the specified domain.
      *
      * @param int $id Domain identifier
      *
      * @return \Illuminate\Http\JsonResponse|void
      */
     public function show($id)
     {
         $domain = Domain::findOrFail($id);
 
         // Only owner (or admin) has access to the domain
         if (!Auth::guard()->user()->canRead($domain)) {
             return $this->errorResponse(403);
         }
 
         $response = $domain->toArray();
 
         // Add hash information to the response
         $response['hash_text'] = $domain->hash(Domain::HASH_TEXT);
         $response['hash_cname'] = $domain->hash(Domain::HASH_CNAME);
         $response['hash_code'] = $domain->hash(Domain::HASH_CODE);
 
         // Add DNS/MX configuration for the domain
         $response['dns'] = self::getDNSConfig($domain);
         $response['config'] = self::getMXConfig($domain->namespace);
 
         // Status info
         $response['statusInfo'] = self::statusInfo($domain);
 
         $response = array_merge($response, self::domainStatuses($domain));
 
         return response()->json($response);
     }
 
     /**
      * Update the specified resource in storage.
      *
      * @param \Illuminate\Http\Request $request
      * @param int                      $id
      *
      * @return \Illuminate\Http\Response
      */
     public function update(Request $request, $id)
     {
         //
     }
 
     /**
      * Provide DNS MX information to configure specified domain for
      */
     protected static function getMXConfig(string $namespace): array
     {
         $entries = [];
 
         // copy MX entries from an existing domain
         if ($master = \config('dns.copyfrom')) {
             // TODO: cache this lookup
             foreach ((array) dns_get_record($master, DNS_MX) as $entry) {
                 $entries[] = sprintf(
                     "@\t%s\t%s\tMX\t%d %s.",
                     \config('dns.ttl', $entry['ttl']),
                     $entry['class'],
                     $entry['pri'],
                     $entry['target']
                 );
             }
         } elseif ($static = \config('dns.static')) {
             $entries[] = strtr($static, array('\n' => "\n", '%s' => $namespace));
         }
 
         // display SPF settings
         if ($spf = \config('dns.spf')) {
             $entries[] = ';';
             foreach (['TXT', 'SPF'] as $type) {
                 $entries[] = sprintf(
                     "@\t%s\tIN\t%s\t\"%s\"",
                     \config('dns.ttl'),
                     $type,
                     $spf
                 );
             }
         }
 
         return $entries;
     }
 
     /**
      * Provide sample DNS config for domain confirmation
      */
     protected static function getDNSConfig(Domain $domain): array
     {
         $serial = date('Ymd01');
         $hash_txt = $domain->hash(Domain::HASH_TEXT);
         $hash_cname = $domain->hash(Domain::HASH_CNAME);
         $hash = $domain->hash(Domain::HASH_CODE);
 
         return [
             "@   IN  SOA ns1.dnsservice.com. hostmaster.{$domain->namespace}. (",
             "        {$serial}  10800  3600  604800  86400 )",
             ";",
             "@       IN  A   <some-ip>",
             "www     IN  A   <some-ip>",
             ";",
             "{$hash_cname}.{$domain->namespace}. IN CNAME {$hash}.{$domain->namespace}.",
             "@   3600    TXT \"{$hash_txt}\"",
         ];
     }
 
     /**
      * Prepare domain statuses for the UI
      *
      * @param \App\Domain $domain Domain object
      *
      * @return array Statuses array
      */
     protected static function domainStatuses(Domain $domain): array
     {
         return [
             'isLdapReady' => $domain->isLdapReady(),
             'isConfirmed' => $domain->isConfirmed(),
             'isVerified' => $domain->isVerified(),
             'isSuspended' => $domain->isSuspended(),
             'isActive' => $domain->isActive(),
             'isDeleted' => $domain->isDeleted() || $domain->trashed(),
         ];
     }
 
     /**
      * Domain status (extended) information.
      *
      * @param \App\Domain $domain Domain object
      *
      * @return array Status information
      */
     public static function statusInfo(Domain $domain): array
     {
         $process = [];
 
         // If that is not a public domain, add domain specific steps
         $steps = [
             'domain-new' => true,
             'domain-ldap-ready' => $domain->isLdapReady(),
             'domain-verified' => $domain->isVerified(),
             'domain-confirmed' => $domain->isConfirmed(),
         ];
 
         $count = count($steps);
 
         // Create a process check list
         foreach ($steps as $step_name => $state) {
             $step = [
                 'label' => $step_name,
                 'title' => \trans("app.process-{$step_name}"),
                 'state' => $state,
             ];
 
             if ($step_name == 'domain-confirmed' && !$state) {
                 $step['link'] = "/domain/{$domain->id}";
             }
 
             $process[] = $step;
 
             if ($state) {
                 $count--;
             }
         }
 
         return [
             'process' => $process,
             'isReady' => $count === 0,
         ];
     }
 }
diff --git a/src/resources/vue/Domain/Info.vue b/src/resources/vue/Domain/Info.vue
index 9b9cc539..d22b44ff 100644
--- a/src/resources/vue/Domain/Info.vue
+++ b/src/resources/vue/Domain/Info.vue
@@ -1,118 +1,117 @@
 <template>
     <div class="container">
         <div v-if="!isReady" id="domain-status-box" class="card">
             <div class="card-body">
                 <div class="card-title">Domain status: <span class="text-danger">Not ready</span></div>
                 <div class="card-text">
                     <p>The process to create the domain have not been completed yet.
                         Some features may be disabled or readonly.</p>
                     <ul class="status-list">
                         <li v-for="item in statusProcess" :key="item.label">
                             <svg-icon :icon="['far', item.state ? 'check-square' : 'square']"
                                       :class="item.state ? 'text-success' : 'text-muted'"
                             ></svg-icon>
-                            <router-link v-if="item.link" :to="{ path: item.link }">{{ item.title }}</router-link>
-                            <span v-if="!item.link">{{ item.title }}</span>
+                            <span>{{ item.title }}</span>
                         </li>
                     </ul>
                 </div>
             </div>
         </div>
         <div v-if="domain && !domain.isConfirmed" class="card" id="domain-verify">
             <div class="card-body">
                 <div class="card-title">Domain verification</div>
                 <div class="card-text">
                     <p>In order to confirm that you're the actual holder of the domain,
                         we need to run a verification process before finally activating it for email delivery.</p>
                     <p>The domain <b>must have one of the following entries</b> in DNS:
                         <ul>
                             <li>TXT entry with value: <code>{{ domain.hash_text }}</code></li>
                             <li>or CNAME entry: <code>{{ domain.hash_cname }}.{{ domain.namespace }}. IN CNAME {{ domain.hash_code }}.{{ domain.namespace }}.</code></li>
                         </ul>
                         When this is done press the button below to start the verification.</p>
                     <p>Here's a sample zone file for your domain: <pre>{{ domain.dns.join("\n") }}</pre></p>
                     <button class="btn btn-primary" type="button" @click="confirm"><svg-icon icon="sync-alt"></svg-icon> Verify</button>
                 </div>
             </div>
         </div>
         <div v-if="domain && domain.isConfirmed" class="card" id="domain-config">
             <div class="card-body">
                 <div class="card-title">Domain configuration</div>
                 <div class="card-text">
                     <p>In order to let {{ app_name }} receive email traffic for your domain you need to adjust
                         the DNS settings, more precisely the MX entries, accordingly.</p>
                     <p>Edit your domain's zone file and replace existing MX
                         entries with the following values: <pre>{{ domain.config.join("\n") }}</pre></p>
                     <p>If you don't know how to set DNS entries for your domain,
                         please contact the registration service where you registered
                         the domain or your web hosting provider.</p>
                 </div>
             </div>
         </div>
     </div>
 </template>
 
 <script>
     export default {
         data() {
             return {
                 domain_id: null,
                 domain: null,
                 app_name: window.config['app.name'],
                 isReady: true,
                 statusProcess: []
             }
         },
         created() {
             if (this.domain_id = this.$route.params.domain) {
                 axios.get('/api/v4/domains/' + this.domain_id)
                     .then(response => {
                         this.domain = response.data
                         if (!this.domain.isConfirmed) {
                             $('#domain-verify button').focus()
                         }
                         this.parseStatusInfo(response.data.statusInfo)
                     })
                     .catch(this.$root.errorHandler)
             } else {
                 this.$root.errorPage(404)
             }
         },
         destroyed() {
             clearTimeout(window.domainRequest)
         },
         methods: {
             confirm() {
                 axios.get('/api/v4/domains/' + this.domain_id + '/confirm')
                     .then(response => {
                         if (response.data.status == 'success') {
                             this.domain.isConfirmed = true
                             this.parseStatusInfo(response.data.statusInfo)
                             this.$toastr('success', response.data.message)
                         }
                     })
             },
             // Displays domain status information
             parseStatusInfo(info) {
                 this.statusProcess = info.process
                 this.isReady = info.isReady
 
                 // 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.isReady) {
                     window.domainRequest = setTimeout(() => {
                         axios.get('/api/v4/domains/' + this.domain_id)
                             .then(response => {
                                 this.domain = response.data
                                 this.parseStatusInfo(this.domain.statusInfo)
                             })
                             .catch(error => {
                                 this.parseStatusInfo(info)
                             })
                     }, 10000);
                 }
             },
         }
     }
 </script>
diff --git a/src/resources/vue/User/List.vue b/src/resources/vue/User/List.vue
index 16ce9a32..f52191d4 100644
--- a/src/resources/vue/User/List.vue
+++ b/src/resources/vue/User/List.vue
@@ -1,124 +1,124 @@
 <template>
     <div class="container">
         <div class="card" id="user-list">
             <div class="card-body">
                 <div class="card-title">
                     User Accounts
-                    <router-link class="btn btn-success float-right create-user" :to="{ path: 'user/new' }" tag="button">
+                    <router-link class="btn btn-primary float-right create-user" :to="{ path: 'user/new' }" tag="button">
                         <svg-icon icon="user"></svg-icon> Create user
                     </router-link>
                 </div>
                 <div class="card-text">
                     <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>
                                     <svg-icon icon="user" :class="$root.userStatusClass(user)" :title="$root.userStatusText(user)"></svg-icon>
                                     <router-link :to="{ path: 'user/' + user.id }">{{ user.email }}</router-link>
                                 </td>
                                 <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.php b/src/tests/Browser.php
index f5262de2..d45bec0a 100644
--- a/src/tests/Browser.php
+++ b/src/tests/Browser.php
@@ -1,152 +1,165 @@
 <?php
 
 namespace Tests;
 
 use Facebook\WebDriver\WebDriverKeys;
 use PHPUnit\Framework\Assert;
 use Tests\Browser\Components\Error;
 
 /**
  * Laravel Dusk Browser extensions
  */
 class Browser extends \Laravel\Dusk\Browser
 {
     /**
      * Assert number of (visible) elements
      */
     public function assertElementsCount($selector, $expected_count, $visible = true)
     {
         $elements = $this->elements($selector);
         $count = count($elements);
 
         if ($visible) {
             foreach ($elements as $element) {
                 if (!$element->isDisplayed()) {
                     $count--;
                 }
             }
         }
 
-        Assert::assertEquals($expected_count, $count);
+        Assert::assertEquals($expected_count, $count, "Count of [$selector] elements is not $count");
 
         return $this;
     }
 
     /**
      * Assert Tip element content
      */
     public function assertTip($selector, $content)
     {
         return $this->click($selector)
             ->withinBody(function ($browser) use ($content) {
                 $browser->assertSeeIn('div.tooltip .tooltip-inner', $content);
             })
             ->click($selector);
     }
 
     /**
      * Assert specified error page is displayed.
      */
     public function assertErrorPage(int $error_code)
     {
         $this->with(new Error($error_code), function ($browser) {
             // empty, assertions will be made by the Error component itself
         });
 
         return $this;
     }
 
     /**
      * Assert that the given element has specified class assigned.
      */
     public function assertHasClass($selector, $class_name)
     {
         $element = $this->resolver->findOrFail($selector);
         $classes = explode(' ', (string) $element->getAttribute('class'));
 
-        Assert::assertContains($class_name, $classes);
+        Assert::assertContains($class_name, $classes, "[$selector] has no class '{$class_name}'");
+
+        return $this;
+    }
+
+    /**
+     * Assert that the given element contains specified text,
+     * no matter it's displayed or not.
+     */
+    public function assertText($selector, $text)
+    {
+        $element = $this->resolver->findOrFail($selector);
+
+        Assert::assertTrue(strpos($element->getText(), $text) !== false, "No expected text in [$selector]");
 
         return $this;
     }
 
     /**
      * Remove all toast messages
      */
     public function clearToasts()
     {
         $this->script("jQuery('.toast-container > *').remove()");
 
         return $this;
     }
 
     /**
      * Check if in Phone mode
      */
     public static function isPhone()
     {
         return getenv('TESTS_MODE') == 'phone';
     }
 
     /**
      * Check if in Tablet mode
      */
     public static function isTablet()
     {
         return getenv('TESTS_MODE') == 'tablet';
     }
 
     /**
      * Check if in Desktop mode
      */
     public static function isDesktop()
     {
         return !self::isPhone() && !self::isTablet();
     }
 
     /**
      * Returns content of a downloaded file
      */
     public function readDownloadedFile($filename)
     {
         $filename = __DIR__ . "/Browser/downloads/$filename";
 
         // Give the browser a chance to finish download
         if (!file_exists($filename)) {
             sleep(2);
         }
 
         Assert::assertFileExists($filename);
 
         return file_get_contents($filename);
     }
 
     /**
      * Removes downloaded file
      */
     public function removeDownloadedFile($filename)
     {
         @unlink(__DIR__ . "/Browser/downloads/$filename");
 
         return $this;
     }
 
     /**
      * Execute code within body context.
      * Useful to execute code that selects elements outside of a component context
      */
     public function withinBody($callback)
     {
         if ($this->resolver->prefix != 'body') {
             $orig_prefix = $this->resolver->prefix;
             $this->resolver->prefix = 'body';
         }
 
         call_user_func($callback, $this);
 
         if (isset($orig_prefix)) {
             $this->resolver->prefix = $orig_prefix;
         }
 
         return $this;
     }
 }
diff --git a/src/tests/Browser/DomainTest.php b/src/tests/Browser/DomainTest.php
index 86f01a18..11585d02 100644
--- a/src/tests/Browser/DomainTest.php
+++ b/src/tests/Browser/DomainTest.php
@@ -1,134 +1,135 @@
 <?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\TestCaseDusk;
 use Illuminate\Foundation\Testing\DatabaseMigrations;
 
 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())
-                // TODO: Test domain status box
+                ->assertVisible('@status')
                 ->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())
-                // TODO: Assert domain status icon
+                ->assertVisible('@table tbody tr:first-child td:first-child svg.fa-globe.text-success')
+                ->assertText('@table tbody tr:first-child td:first-child svg title', 'Active')
                 ->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/LogonTest.php b/src/tests/Browser/LogonTest.php
index 35d30b74..3fb95140 100644
--- a/src/tests/Browser/LogonTest.php
+++ b/src/tests/Browser/LogonTest.php
@@ -1,158 +1,159 @@
 <?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())
                 ->within(new Menu(), function ($browser) {
                     $browser->assertMenuItems(['support', 'contact', 'webmail', 'logout']);
                 })
                 ->assertUser('john@kolab.org');
 
-            // TODO: Verify dashboard content
+            // Assert no "Account status" for this account
+            $browser->assertMissing('@status');
 
             // 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 feb95dc3..4fd18e93 100644
--- a/src/tests/Browser/Pages/Dashboard.php
+++ b/src/tests/Browser/Pages/Dashboard.php
@@ -1,56 +1,57 @@
 <?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',
+            '@status' => '#status-box',
         ];
     }
 }
diff --git a/src/tests/Browser/StatusTest.php b/src/tests/Browser/StatusTest.php
new file mode 100644
index 00000000..a2c51e33
--- /dev/null
+++ b/src/tests/Browser/StatusTest.php
@@ -0,0 +1,167 @@
+<?php
+
+namespace Tests\Browser;
+
+use App\Domain;
+use App\User;
+use Tests\Browser;
+use Tests\Browser\Pages\Dashboard;
+use Tests\Browser\Pages\DomainInfo;
+use Tests\Browser\Pages\DomainList;
+use Tests\Browser\Pages\Home;
+use Tests\Browser\Pages\UserInfo;
+use Tests\Browser\Pages\UserList;
+use Tests\TestCaseDusk;
+use Illuminate\Support\Facades\DB;
+
+class StatusTest extends TestCaseDusk
+{
+    /**
+     * {@inheritDoc}
+     */
+    public function setUp(): void
+    {
+        parent::setUp();
+
+        DB::statement("UPDATE domains SET status = (status | " . Domain::STATUS_CONFIRMED . ")"
+            . " WHERE namespace = 'kolab.org'");
+        DB::statement("UPDATE users SET status = (status | " . User::STATUS_IMAP_READY . ")"
+            . " WHERE email = 'john@kolab.org'");
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    public function tearDown(): void
+    {
+        DB::statement("UPDATE domains SET status = (status | " . Domain::STATUS_CONFIRMED . ")"
+            . " WHERE namespace = 'kolab.org'");
+        DB::statement("UPDATE users SET status = (status | " . User::STATUS_IMAP_READY . ")"
+            . " WHERE email = 'john@kolab.org'");
+
+        parent::tearDown();
+    }
+
+    /**
+     * Test account status in the Dashboard
+     */
+    public function testDashboard(): void
+    {
+        // Unconfirmed domain
+        $domain = Domain::where('namespace', 'kolab.org')->first();
+        $domain->status ^= Domain::STATUS_CONFIRMED;
+        $domain->save();
+
+        $this->browse(function ($browser) use ($domain) {
+            $browser->visit(new Home())
+                ->submitLogon('john@kolab.org', 'simple123', true)
+                ->on(new Dashboard())
+                ->whenAvailable('@status', function ($browser) {
+                    $browser->assertSeeIn('.card-title', 'Account status:')
+                        ->assertSeeIn('.card-title span.text-danger', 'Not ready')
+                        ->with('ul.status-list', function ($browser) {
+                            $browser->assertElementsCount('li', 7)
+                                ->assertVisible('li:nth-child(1) svg.fa-check-square')
+                                ->assertSeeIn('li:nth-child(1) span', 'User registered')
+                                ->assertVisible('li:nth-child(2) svg.fa-check-square')
+                                ->assertSeeIn('li:nth-child(2) span', 'User created')
+                                ->assertVisible('li:nth-child(3) svg.fa-check-square')
+                                ->assertSeeIn('li:nth-child(3) span', 'User mailbox created')
+                                ->assertVisible('li:nth-child(4) svg.fa-check-square')
+                                ->assertSeeIn('li:nth-child(4) span', 'Custom domain registered')
+                                ->assertVisible('li:nth-child(5) svg.fa-check-square')
+                                ->assertSeeIn('li:nth-child(5) span', 'Custom domain created')
+                                ->assertVisible('li:nth-child(6) svg.fa-check-square')
+                                ->assertSeeIn('li:nth-child(6) span', 'Custom domain verified')
+                                ->assertVisible('li:nth-child(7) svg.fa-square')
+                                ->assertSeeIn('li:nth-child(7) a', 'Custom domain ownership verified');
+                        });
+                });
+
+            // Confirm the domain and wait until the whole status box disappears
+            $domain->status |= Domain::STATUS_CONFIRMED;
+            $domain->save();
+
+            // At the moment, this may take about 10 seconds
+            $browser->waitUntilMissing('@status', 15);
+        });
+    }
+
+    /**
+     * Test domain status on domains list and domain info page
+     *
+     * @depends testDashboard
+     */
+    public function testDomainStatus(): void
+    {
+        $domain = Domain::where('namespace', 'kolab.org')->first();
+        $domain->status ^= Domain::STATUS_CONFIRMED;
+        $domain->save();
+
+        $this->browse(function ($browser) use ($domain) {
+            $browser->on(new Dashboard())
+                ->click('@links a.link-domains')
+                ->on(new DomainList())
+                // Assert domain status icon
+                ->assertVisible('@table tbody tr:first-child td:first-child svg.fa-globe.text-danger')
+                ->assertText('@table tbody tr:first-child td:first-child svg title', 'Not Ready')
+                ->click('@table tbody tr:first-child td:first-child a')
+                ->on(new DomainInfo())
+                ->whenAvailable('@status', function ($browser) {
+                    $browser->assertSeeIn('.card-title', 'Domain status:')
+                        ->assertSeeIn('.card-title span.text-danger', 'Not ready')
+                        ->with('ul.status-list', function ($browser) {
+                            $browser->assertElementsCount('li', 4)
+                                ->assertVisible('li:nth-child(1) svg.fa-check-square')
+                                ->assertSeeIn('li:nth-child(1) span', 'Custom domain registered')
+                                ->assertVisible('li:nth-child(2) svg.fa-check-square')
+                                ->assertSeeIn('li:nth-child(2) span', 'Custom domain created')
+                                ->assertVisible('li:nth-child(3) svg.fa-check-square')
+                                ->assertSeeIn('li:nth-child(3) span', 'Custom domain verified')
+                                ->assertVisible('li:nth-child(4) svg.fa-square')
+                                ->assertSeeIn('li:nth-child(4) span', 'Custom domain ownership verified');
+                        });
+                });
+
+            // Confirm the domain and wait until the whole status box disappears
+            $domain->status |= Domain::STATUS_CONFIRMED;
+            $domain->save();
+
+            // At the moment, this may take about 10 seconds
+            $browser->waitUntilMissing('@status', 15);
+        });
+    }
+
+    /**
+     * Test user status on users list
+     *
+     * @depends testDashboard
+     */
+    public function testUserStatus(): void
+    {
+        $john = $this->getTestUser('john@kolab.org');
+        $john->status ^= User::STATUS_IMAP_READY;
+        $john->save();
+
+        $this->browse(function ($browser) {
+            $browser->visit(new Dashboard())
+                ->click('@links a.link-users')
+                ->on(new UserList())
+                // Assert user status icons
+                ->assertVisible('@table tbody tr:first-child td:first-child svg.fa-user.text-success')
+                ->assertText('@table tbody tr:first-child td:first-child svg title', 'Active')
+                ->assertVisible('@table tbody tr:nth-child(2) td:first-child svg.fa-user.text-danger')
+                ->assertText('@table tbody tr:nth-child(2) td:first-child svg title', 'Not Ready')
+                ->click('@table tbody tr:nth-child(2) td:first-child a')
+                ->on(new UserInfo())
+                ->with('@form', function (Browser $browser) {
+                    // Assert stet in the user edit form
+                    $browser->assertSeeIn('div.row:nth-child(1) label', 'Status')
+                        ->assertSeeIn('div.row:nth-child(1) #status', 'Not Ready');
+                });
+
+            // TODO: The status should also be live-updated here
+            //       Maybe when we have proper websocket communication
+        });
+    }
+}