diff --git a/src/app/Http/Controllers/API/V4/UsersController.php b/src/app/Http/Controllers/API/V4/UsersController.php
index ca253cbd..5e5613b9 100644
--- a/src/app/Http/Controllers/API/V4/UsersController.php
+++ b/src/app/Http/Controllers/API/V4/UsersController.php
@@ -1,702 +1,699 @@
 <?php
 
 namespace App\Http\Controllers\API\V4;
 
 use App\Http\Controllers\RelationController;
 use App\Domain;
 use App\Rules\Password;
 use App\Rules\UserEmailDomain;
 use App\Rules\UserEmailLocal;
 use App\Sku;
 use App\User;
 use Illuminate\Http\Request;
 use Illuminate\Support\Facades\DB;
 use Illuminate\Support\Facades\Validator;
 use Illuminate\Support\Str;
 
 class UsersController extends RelationController
 {
     /** @const array List of user setting keys available for modification in UI */
     public const USER_SETTINGS = [
         'billing_address',
         'country',
         'currency',
         'external_email',
         'first_name',
         'last_name',
         'organization',
         'phone',
     ];
 
     /**
      * On user create it is filled with a user or group object to force-delete
      * before the creation of a new user record is possible.
      *
      * @var \App\User|\App\Group|null
      */
     protected $deleteBeforeCreate;
 
     /** @var string Resource localization label */
     protected $label = 'user';
 
     /** @var string Resource model name */
     protected $model = User::class;
 
     /** @var array Common object properties in the API response */
     protected $objectProps = ['email'];
 
     /** @var ?\App\VerificationCode Password reset code to activate on user create/update */
     protected $passCode;
 
     /**
      * Listing of users.
      *
      * The user-entitlements billed to the current user wallet(s)
      *
      * @return \Illuminate\Http\JsonResponse
      */
     public function index()
     {
         $user = $this->guard()->user();
         $search = trim(request()->input('search'));
         $page = intval(request()->input('page')) ?: 1;
         $pageSize = 20;
         $hasMore = false;
 
         $result = $user->users();
 
         // Search by user email, alias or name
         if (strlen($search) > 0) {
             // thanks to cloning we skip some extra queries in $user->users()
             $allUsers1 = clone $result;
             $allUsers2 = clone $result;
 
             $result->whereLike('email', $search)
                 ->union(
                     $allUsers1->join('user_aliases', 'users.id', '=', 'user_aliases.user_id')
                         ->whereLike('alias', $search)
                 )
                 ->union(
                     $allUsers2->join('user_settings', 'users.id', '=', 'user_settings.user_id')
                         ->whereLike('value', $search)
                         ->whereIn('key', ['first_name', 'last_name'])
                 );
         }
 
         $result = $result->orderBy('email')
             ->limit($pageSize + 1)
             ->offset($pageSize * ($page - 1))
             ->get();
 
         if (count($result) > $pageSize) {
             $result->pop();
             $hasMore = true;
         }
 
         // Process the result
         $result = $result->map(
             function ($user) {
                 return $this->objectToClient($user);
             }
         );
 
         $result = [
             'list' => $result,
             'count' => count($result),
             'hasMore' => $hasMore,
         ];
 
         return response()->json($result);
     }
 
     /**
      * Display information on the user account specified by $id.
      *
      * @param string $id The account to show information for.
      *
      * @return \Illuminate\Http\JsonResponse
      */
     public function show($id)
     {
         $user = User::find($id);
 
         if (!$this->checkTenant($user)) {
             return $this->errorResponse(404);
         }
 
         if (!$this->guard()->user()->canRead($user)) {
             return $this->errorResponse(403);
         }
 
         $response = $this->userResponse($user);
 
         $response['skus'] = \App\Entitlement::objectEntitlementsSummary($user);
         $response['config'] = $user->getConfig();
         $response['aliases'] = $user->aliases()->pluck('alias')->all();
 
         $code = $user->verificationcodes()->where('active', true)
             ->where('expires_at', '>', \Carbon\Carbon::now())
             ->first();
 
         if ($code) {
             $response['passwordLinkCode'] = $code->short_code . '-' . $code->code;
         }
 
         return response()->json($response);
     }
 
     /**
      * User status (extended) information
      *
      * @param \App\User $user User object
      *
      * @return array Status information
      */
     public static function statusInfo($user): array
     {
         $process = self::processStateInfo(
             $user,
             [
                 'user-new' => true,
                 'user-ldap-ready' => $user->isLdapReady(),
                 'user-imap-ready' => $user->isImapReady(),
             ]
         );
 
         // Check if the user is a controller of his wallet
         $isController = $user->canDelete($user);
 
         $isDegraded = $user->isDegraded();
         $hasMeet = !$isDegraded && Sku::withObjectTenantContext($user)->where('title', 'room')->exists();
         $hasCustomDomain = $user->wallet()->entitlements()
             ->where('entitleable_type', Domain::class)
             ->count() > 0;
 
         // Get user's entitlements titles
         $skus = $user->entitlements()->select('skus.title')
             ->join('skus', 'skus.id', '=', 'entitlements.sku_id')
             ->get()
             ->pluck('title')
             ->sort()
             ->unique()
             ->values()
             ->all();
 
         $hasBeta = in_array('beta', $skus);
 
         $result = [
             'skus' => $skus,
             'enableBeta' => in_array('beta', $skus),
             // TODO: This will change when we enable all users to create domains
             'enableDomains' => $isController && $hasCustomDomain,
             // TODO: Make 'enableDistlists' working for wallet controllers that aren't account owners
             'enableDistlists' => $isController && $hasCustomDomain && $hasBeta,
             'enableFiles' => !$isDegraded && $hasBeta && \config('app.with_files'),
             // TODO: Make 'enableFolders' working for wallet controllers that aren't account owners
             'enableFolders' => $isController && $hasCustomDomain && $hasBeta,
             // TODO: Make 'enableResources' working for wallet controllers that aren't account owners
             'enableResources' => $isController && $hasCustomDomain && $hasBeta,
             'enableRooms' => $hasMeet,
             'enableSettings' => $isController,
             'enableUsers' => $isController,
             'enableWallets' => $isController,
             'enableCompanionapps' => $hasBeta,
         ];
 
         return array_merge($process, $result);
     }
 
     /**
      * Create a new user record.
      *
      * @param \Illuminate\Http\Request $request The API request.
      *
      * @return \Illuminate\Http\JsonResponse The response
      */
     public function store(Request $request)
     {
         $current_user = $this->guard()->user();
         $owner = $current_user->walletOwner();
 
         if ($owner->id != $current_user->id) {
             return $this->errorResponse(403);
         }
 
         $this->deleteBeforeCreate = null;
 
         if ($error_response = $this->validateUserRequest($request, null, $settings)) {
             return $error_response;
         }
 
         if (empty($request->package) || !($package = \App\Package::withEnvTenantContext()->find($request->package))) {
             $errors = ['package' => \trans('validation.packagerequired')];
             return response()->json(['status' => 'error', 'errors' => $errors], 422);
         }
 
         if ($package->isDomain()) {
             $errors = ['package' => \trans('validation.packageinvalid')];
             return response()->json(['status' => 'error', 'errors' => $errors], 422);
         }
 
         DB::beginTransaction();
 
         // @phpstan-ignore-next-line
         if ($this->deleteBeforeCreate) {
             $this->deleteBeforeCreate->forceDelete();
         }
 
         // Create user record
         $user = User::create([
                 'email' => $request->email,
                 'password' => $request->password,
         ]);
 
         $this->activatePassCode($user);
 
         $owner->assignPackage($package, $user);
 
         if (!empty($settings)) {
             $user->setSettings($settings);
         }
 
         if (!empty($request->aliases)) {
             $user->setAliases($request->aliases);
         }
 
         DB::commit();
 
         return response()->json([
                 'status' => 'success',
                 'message' => \trans('app.user-create-success'),
         ]);
     }
 
     /**
      * Update user data.
      *
      * @param \Illuminate\Http\Request $request The API request.
      * @param string                   $id      User identifier
      *
      * @return \Illuminate\Http\JsonResponse The response
      */
     public function update(Request $request, $id)
     {
         $user = User::withEnvTenantContext()->find($id);
 
         if (empty($user)) {
             return $this->errorResponse(404);
         }
 
         $current_user = $this->guard()->user();
 
         // TODO: Decide what attributes a user can change on his own profile
         if (!$current_user->canUpdate($user)) {
             return $this->errorResponse(403);
         }
 
         if ($error_response = $this->validateUserRequest($request, $user, $settings)) {
             return $error_response;
         }
 
         // Entitlements, only controller can do that
         if ($request->skus !== null && !$current_user->canDelete($user)) {
             return $this->errorResponse(422, "You have no permission to change entitlements");
         }
 
         DB::beginTransaction();
 
         SkusController::updateEntitlements($user, $request->skus);
 
         if (!empty($settings)) {
             $user->setSettings($settings);
         }
 
         if (!empty($request->password)) {
             $user->password = $request->password;
             $user->save();
         }
 
         $this->activatePassCode($user);
 
         if (isset($request->aliases)) {
             $user->setAliases($request->aliases);
         }
 
         DB::commit();
 
         $response = [
             'status' => 'success',
             'message' => \trans('app.user-update-success'),
         ];
 
         // For self-update refresh the statusInfo in the UI
         if ($user->id == $current_user->id) {
             $response['statusInfo'] = self::statusInfo($user);
         }
 
         return response()->json($response);
     }
 
     /**
      * Create a response data array for specified user.
      *
      * @param \App\User $user User object
      *
      * @return array Response data
      */
     public static function userResponse(User $user): array
     {
         $response = array_merge($user->toArray(), self::objectState($user));
 
         // Settings
         $response['settings'] = [];
         foreach ($user->settings()->whereIn('key', self::USER_SETTINGS)->get() as $item) {
             $response['settings'][$item->key] = $item->value;
         }
 
         // Status info
         $response['statusInfo'] = self::statusInfo($user);
 
         // Add more info to the wallet object output
         $map_func = function ($wallet) use ($user) {
             $result = $wallet->toArray();
 
             if ($wallet->discount) {
                 $result['discount'] = $wallet->discount->discount;
                 $result['discount_description'] = $wallet->discount->description;
             }
 
             if ($wallet->user_id != $user->id) {
                 $result['user_email'] = $wallet->owner->email;
             }
 
             $provider = \App\Providers\PaymentProvider::factory($wallet);
             $result['provider'] = $provider->name();
 
             return $result;
         };
 
         // Information about wallets and accounts for access checks
         $response['wallets'] = $user->wallets->map($map_func)->toArray();
         $response['accounts'] = $user->accounts->map($map_func)->toArray();
         $response['wallet'] = $map_func($user->wallet());
 
         return $response;
     }
 
     /**
      * Prepare user statuses for the UI
      *
      * @param \App\User $user User object
      *
      * @return array Statuses array
      */
     protected static function objectState($user): array
     {
         $state = parent::objectState($user);
 
         $state['isAccountDegraded'] = $user->isDegraded(true);
 
         return $state;
     }
 
     /**
      * Validate user input
      *
      * @param \Illuminate\Http\Request $request  The API request.
      * @param \App\User|null           $user     User identifier
      * @param array                    $settings User settings (from the request)
      *
      * @return \Illuminate\Http\JsonResponse|null The error response on error
      */
     protected function validateUserRequest(Request $request, $user, &$settings = [])
     {
         $rules = [
             'external_email' => 'nullable|email',
             'phone' => 'string|nullable|max:64|regex:/^[0-9+() -]+$/',
             'first_name' => 'string|nullable|max:128',
             'last_name' => 'string|nullable|max:128',
             'organization' => 'string|nullable|max:512',
             'billing_address' => 'string|nullable|max:1024',
             'country' => 'string|nullable|alpha|size:2',
             'currency' => 'string|nullable|alpha|size:3',
             'aliases' => 'array|nullable',
         ];
 
         $controller = ($user ?: $this->guard()->user())->walletOwner();
 
         // Handle generated password reset code
         if ($code = $request->input('passwordLinkCode')) {
             // Accept <short-code>-<code> input
             if (strpos($code, '-')) {
                 $code = explode('-', $code)[1];
             }
 
             $this->passCode = $this->guard()->user()->verificationcodes()
                 ->where('code', $code)->where('active', false)->first();
 
             // Generate a password for a new user with password reset link
             // FIXME: Should/can we have a user with no password set?
             if ($this->passCode && empty($user)) {
                 $request->password = $request->password_confirmation = Str::random(16);
                 $ignorePassword = true;
             }
         }
 
         if (empty($user) || !empty($request->password) || !empty($request->password_confirmation)) {
             if (empty($ignorePassword)) {
                 $rules['password'] = ['required', 'confirmed', new Password($controller)];
             }
         }
 
         $errors = [];
 
         // Validate input
         $v = Validator::make($request->all(), $rules);
 
         if ($v->fails()) {
             $errors = $v->errors()->toArray();
         }
 
         // For new user validate email address
         if (empty($user)) {
             $email = $request->email;
 
             if (empty($email)) {
                 $errors['email'] = \trans('validation.required', ['attribute' => 'email']);
             } elseif ($error = self::validateEmail($email, $controller, $this->deleteBeforeCreate)) {
                 $errors['email'] = $error;
             }
         }
 
         // Validate aliases input
         if (isset($request->aliases)) {
             $aliases = [];
             $existing_aliases = $user ? $user->aliases()->get()->pluck('alias')->toArray() : [];
 
             foreach ($request->aliases as $idx => $alias) {
                 if (is_string($alias) && !empty($alias)) {
                     // Alias cannot be the same as the email address (new user)
                     if (!empty($email) && Str::lower($alias) == Str::lower($email)) {
                         continue;
                     }
 
                     // validate new aliases
                     if (
                         !in_array($alias, $existing_aliases)
                         && ($error = self::validateAlias($alias, $controller))
                     ) {
                         if (!isset($errors['aliases'])) {
                             $errors['aliases'] = [];
                         }
                         $errors['aliases'][$idx] = $error;
                         continue;
                     }
 
                     $aliases[] = $alias;
                 }
             }
 
             $request->aliases = $aliases;
         }
 
         if (!empty($errors)) {
             return response()->json(['status' => 'error', 'errors' => $errors], 422);
         }
 
         // Update user settings
         $settings = $request->only(array_keys($rules));
         unset($settings['password'], $settings['aliases'], $settings['email']);
 
         return null;
     }
 
     /**
      * Execute (synchronously) specified step in a user setup process.
      *
      * @param \App\User $user User object
      * @param string    $step Step identifier (as in self::statusInfo())
      *
      * @return bool|null True if the execution succeeded, False if not, Null when
      *                   the job has been sent to the worker (result unknown)
      */
     public static function execProcessStep(User $user, string $step): ?bool
     {
         try {
             if (strpos($step, 'domain-') === 0) {
-                list ($local, $domain) = explode('@', $user->email);
-                $domain = Domain::where('namespace', $domain)->first();
-
-                return DomainsController::execProcessStep($domain, $step);
+                return DomainsController::execProcessStep($user->domain(), $step);
             }
 
             switch ($step) {
                 case 'user-ldap-ready':
                 case 'user-imap-ready':
                     // Use worker to do the job, frontend might not have the IMAP admin credentials
                     \App\Jobs\User\CreateJob::dispatch($user->id);
                     return null;
             }
         } catch (\Exception $e) {
             \Log::error($e);
         }
 
         return false;
     }
 
     /**
      * Email address validation for use as a user mailbox (login).
      *
      * @param string                    $email   Email address
      * @param \App\User                 $user    The account owner
      * @param null|\App\User|\App\Group $deleted Filled with an instance of a deleted user or group
      *                                           with the specified email address, if exists
      *
      * @return ?string Error message on validation error
      */
     public static function validateEmail(string $email, \App\User $user, &$deleted = null): ?string
     {
         $deleted = null;
 
         if (strpos($email, '@') === false) {
             return \trans('validation.entryinvalid', ['attribute' => 'email']);
         }
 
         list($login, $domain) = explode('@', Str::lower($email));
 
         if (strlen($login) === 0 || strlen($domain) === 0) {
             return \trans('validation.entryinvalid', ['attribute' => 'email']);
         }
 
         // Check if domain exists
         $domain = Domain::withObjectTenantContext($user)->where('namespace', $domain)->first();
 
         if (empty($domain)) {
             return \trans('validation.domaininvalid');
         }
 
         // Validate login part alone
         $v = Validator::make(
             ['email' => $login],
             ['email' => ['required', new UserEmailLocal(!$domain->isPublic())]]
         );
 
         if ($v->fails()) {
             return $v->errors()->toArray()['email'][0];
         }
 
         // Check if it is one of domains available to the user
         if (!$domain->isPublic() && $user->id != $domain->walletOwner()->id) {
             return \trans('validation.entryexists', ['attribute' => 'domain']);
         }
 
         // Check if a user/group/resource/shared folder with specified address already exists
         if (
             ($existing = User::emailExists($email, true))
             || ($existing = \App\Group::emailExists($email, true))
             || ($existing = \App\Resource::emailExists($email, true))
             || ($existing = \App\SharedFolder::emailExists($email, true))
         ) {
             // If this is a deleted user/group/resource/folder in the same custom domain
             // we'll force delete it before creating the target user
             if (!$domain->isPublic() && $existing->trashed()) {
                 $deleted = $existing;
             } else {
                 return \trans('validation.entryexists', ['attribute' => 'email']);
             }
         }
 
         // Check if an alias with specified address already exists.
         if (User::aliasExists($email) || \App\SharedFolder::aliasExists($email)) {
             return \trans('validation.entryexists', ['attribute' => 'email']);
         }
 
         return null;
     }
 
     /**
      * Email address validation for use as an alias.
      *
      * @param string    $email Email address
      * @param \App\User $user  The account owner
      *
      * @return ?string Error message on validation error
      */
     public static function validateAlias(string $email, \App\User $user): ?string
     {
         if (strpos($email, '@') === false) {
             return \trans('validation.entryinvalid', ['attribute' => 'alias']);
         }
 
         list($login, $domain) = explode('@', Str::lower($email));
 
         if (strlen($login) === 0 || strlen($domain) === 0) {
             return \trans('validation.entryinvalid', ['attribute' => 'alias']);
         }
 
         // Check if domain exists
         $domain = Domain::withObjectTenantContext($user)->where('namespace', $domain)->first();
 
         if (empty($domain)) {
             return \trans('validation.domaininvalid');
         }
 
         // Validate login part alone
         $v = Validator::make(
             ['alias' => $login],
             ['alias' => ['required', new UserEmailLocal(!$domain->isPublic())]]
         );
 
         if ($v->fails()) {
             return $v->errors()->toArray()['alias'][0];
         }
 
         // Check if it is one of domains available to the user
         if (!$domain->isPublic() && $user->id != $domain->walletOwner()->id) {
             return \trans('validation.entryexists', ['attribute' => 'domain']);
         }
 
         // Check if a user with specified address already exists
         if ($existing_user = User::emailExists($email, true)) {
             // Allow an alias in a custom domain to an address that was a user before
             if ($domain->isPublic() || !$existing_user->trashed()) {
                 return \trans('validation.entryexists', ['attribute' => 'alias']);
             }
         }
 
         // Check if a group/resource/shared folder with specified address already exists
         if (
             \App\Group::emailExists($email)
             || \App\Resource::emailExists($email)
             || \App\SharedFolder::emailExists($email)
         ) {
             return \trans('validation.entryexists', ['attribute' => 'alias']);
         }
 
         // Check if an alias with specified address already exists
         if (User::aliasExists($email) || \App\SharedFolder::aliasExists($email)) {
             // Allow assigning the same alias to a user in the same group account,
             // but only for non-public domains
             if ($domain->isPublic()) {
                 return \trans('validation.entryexists', ['attribute' => 'alias']);
             }
         }
 
         return null;
     }
 
     /**
      * Activate password reset code (if set), and assign it to a user.
      *
      * @param \App\User $user The user
      */
     protected function activatePassCode(User $user): void
     {
         // Activate the password reset code
         if ($this->passCode) {
             $this->passCode->user_id = $user->id;
             $this->passCode->active = true;
             $this->passCode->save();
         }
     }
 }
diff --git a/src/app/Http/Controllers/RelationController.php b/src/app/Http/Controllers/RelationController.php
index 76374a38..3e1a0c48 100644
--- a/src/app/Http/Controllers/RelationController.php
+++ b/src/app/Http/Controllers/RelationController.php
@@ -1,419 +1,409 @@
 <?php
 
 namespace App\Http\Controllers;
 
 use Illuminate\Support\Str;
 
 class RelationController extends ResourceController
 {
     /** @var array Common object properties in the API response */
     protected $objectProps = [];
 
     /** @var string Resource localization label */
     protected $label = '';
 
     /** @var string Resource model name */
     protected $model = '';
 
     /** @var array Resource listing order (column names) */
     protected $order = [];
 
     /** @var array Resource relation method arguments */
     protected $relationArgs = [];
 
     /**
      * Delete a resource.
      *
      * @param string $id Resource identifier
      *
      * @return \Illuminate\Http\JsonResponse The response
      */
     public function destroy($id)
     {
         $resource = $this->model::find($id);
 
         if (!$this->checkTenant($resource)) {
             return $this->errorResponse(404);
         }
 
         if (!$this->guard()->user()->canDelete($resource)) {
             return $this->errorResponse(403);
         }
 
         $resource->delete();
 
         return response()->json([
                 'status' => 'success',
                 'message' => \trans("app.{$this->label}-delete-success"),
         ]);
     }
 
     /**
      * Listing of resources belonging to the authenticated user.
      *
      * The resource entitlements billed to the current user wallet(s)
      *
      * @return \Illuminate\Http\JsonResponse
      */
     public function index()
     {
         $user = $this->guard()->user();
 
         $method = Str::plural(\lcfirst(\class_basename($this->model)));
 
         $query = call_user_func_array([$user, $method], $this->relationArgs);
 
         if (!empty($this->order)) {
             foreach ($this->order as $col) {
                 $query->orderBy($col);
             }
         }
 
         // TODO: Search and paging
 
         $result = $query->get()
             ->map(function ($resource) {
                 return $this->objectToClient($resource);
             });
 
         $result = [
             'list' => $result,
             'count' => count($result),
             'hasMore' => false,
             'message' => \trans("app.search-foundx{$this->label}s", ['x' => count($result)]),
         ];
 
         return response()->json($result);
     }
 
     /**
      * Prepare resource statuses for the UI
      *
      * @param object $resource Resource object
      *
      * @return array Statuses array
      */
     protected static function objectState($resource): array
     {
         $state = [];
 
         $reflect = new \ReflectionClass(get_class($resource));
 
         foreach (array_keys($reflect->getConstants()) as $const) {
             if (strpos($const, 'STATUS_') === 0 && $const != 'STATUS_NEW') {
                 $method = Str::camel('is_' . strtolower(substr($const, 7)));
                 $state[$method] = $resource->{$method}();
             }
         }
 
-        $with_imap = \config('app.with_imap');
         $with_ldap = \config('app.with_ldap');
 
-        $state['isReady'] = (!$with_imap || !isset($state['isImapReady']) || $state['isImapReady'])
+        $state['isReady'] = (!isset($state['isImapReady']) || $state['isImapReady'])
             && (!$with_ldap || !isset($state['isLdapReady']) || $state['isLdapReady'])
             && (!isset($state['isVerified']) || $state['isVerified'])
             && (!isset($state['isConfirmed']) || $state['isConfirmed']);
 
-        if (!$with_imap) {
-            unset($state['isImapReady']);
-        }
         if (!$with_ldap) {
             unset($state['isLdapReady']);
         }
 
         if (empty($state['isDeleted']) && method_exists($resource, 'trashed')) {
             $state['isDeleted'] = $resource->trashed();
         }
 
         return $state;
     }
 
     /**
      * Prepare a resource object for the UI.
      *
      * @param object $object An object
      * @param bool   $full   Include all object properties
      *
      * @return array Object information
      */
     protected function objectToClient($object, bool $full = false): array
     {
         if ($full) {
             $result = $object->toArray();
 
             unset($result['tenant_id']);
         } else {
             $result = ['id' => $object->id];
 
             foreach ($this->objectProps as $prop) {
                 $result[$prop] = $object->{$prop};
             }
         }
 
         $result = array_merge($result, $this->objectState($object));
 
         return $result;
     }
 
     /**
      * Object status' process information.
      *
      * @param object $object The object to process
      * @param array  $steps  The steps definition
      *
      * @return array Process state information
      */
     protected static function processStateInfo($object, array $steps): array
     {
         $process = [];
         $withLdap = \config('app.with_ldap');
-        $withImap = \config('app.with_imap');
 
         // Create a process check list
         foreach ($steps as $step_name => $state) {
             // Remove LDAP related steps if the backend is disabled
             if (!$withLdap && strpos($step_name, '-ldap-')) {
                 continue;
             }
 
-            // Remove IMAP related steps if the backend is disabled
-            if (!$withImap && strpos($step_name, '-imap-')) {
-                continue;
-            }
-
             $step = [
                 'label' => $step_name,
                 'title' => \trans("app.process-{$step_name}"),
             ];
 
             if (is_array($state)) {
                 $step['link'] = $state[1];
                 $state = $state[0];
             }
 
             $step['state'] = $state;
 
             $process[] = $step;
         }
 
         // Add domain specific steps
         if (method_exists($object, 'domain')) {
             $domain = $object->domain();
 
             // If that is not a public domain
             if ($domain && !$domain->isPublic()) {
                 $domain_status = API\V4\DomainsController::statusInfo($domain);
                 $process = array_merge($process, $domain_status['process']);
             }
         }
 
         $all = count($process);
         $checked = count(array_filter($process, function ($v) {
                 return $v['state'];
         }));
 
         $state = $all === $checked ? 'done' : 'running';
 
         // After 180 seconds assume the process is in failed state,
         // this should unlock the Refresh button in the UI
         if ($all !== $checked && $object->created_at->diffInSeconds(\Carbon\Carbon::now()) > 180) {
             $state = 'failed';
         }
 
         return [
             'process' => $process,
             'processState' => $state,
-            'isReady' => $all === $checked,
+            'isDone' => $all === $checked,
         ];
     }
 
     /**
      * Object status' process information update.
      *
      * @param object $object The object to process
      *
      * @return array Process state information
      */
     protected function processStateUpdate($object): array
     {
         $response = $this->statusInfo($object);
 
         if (!empty(request()->input('refresh'))) {
             $updated = false;
             $async = false;
             $last_step = 'none';
 
             foreach ($response['process'] as $idx => $step) {
                 $last_step = $step['label'];
 
                 if (!$step['state']) {
                     $exec = $this->execProcessStep($object, $step['label']); // @phpstan-ignore-line
 
                     if (!$exec) {
                         if ($exec === null) {
                             $async = true;
                         }
 
                         break;
                     }
 
                     $updated = true;
                 }
             }
 
             if ($updated) {
                 $response = $this->statusInfo($object);
             }
 
-            $success = $response['isReady'];
+            $success = $response['isDone'];
             $suffix = $success ? 'success' : 'error-' . $last_step;
 
             $response['status'] = $success ? 'success' : 'error';
             $response['message'] = \trans('app.process-' . $suffix);
 
             if ($async && !$success) {
                 $response['processState'] = 'waiting';
                 $response['status'] = 'success';
                 $response['message'] = \trans('app.process-async');
             }
         }
 
         return $response;
     }
 
     /**
      * Set the resource configuration.
      *
      * @param int $id Resource identifier
      *
      * @return \Illuminate\Http\JsonResponse|void
      */
     public function setConfig($id)
     {
         $resource = $this->model::find($id);
 
         if (!method_exists($this->model, 'setConfig')) {
             return $this->errorResponse(404);
         }
 
         if (!$this->checkTenant($resource)) {
             return $this->errorResponse(404);
         }
 
         if (!$this->guard()->user()->canUpdate($resource)) {
             return $this->errorResponse(403);
         }
 
         $errors = $resource->setConfig(request()->input());
 
         if (!empty($errors)) {
             return response()->json(['status' => 'error', 'errors' => $errors], 422);
         }
 
         return response()->json([
                 'status' => 'success',
                 'message' => \trans("app.{$this->label}-setconfig-success"),
         ]);
     }
 
     /**
      * Display information of a resource specified by $id.
      *
      * @param string $id The resource to show information for.
      *
      * @return \Illuminate\Http\JsonResponse
      */
     public function show($id)
     {
         $resource = $this->model::find($id);
 
         if (!$this->checkTenant($resource)) {
             return $this->errorResponse(404);
         }
 
         if (!$this->guard()->user()->canRead($resource)) {
             return $this->errorResponse(403);
         }
 
         $response = $this->objectToClient($resource, true);
 
         if (!empty($statusInfo = $this->statusInfo($resource))) {
             $response['statusInfo'] = $statusInfo;
         }
 
         // Resource configuration, e.g. sender_policy, invitation_policy, acl
         if (method_exists($resource, 'getConfig')) {
             $response['config'] = $resource->getConfig();
         }
 
         if (method_exists($resource, 'aliases')) {
             $response['aliases'] = $resource->aliases()->pluck('alias')->all();
         }
 
         // Entitlements/Wallet info
         if (method_exists($resource, 'wallet')) {
             API\V4\SkusController::objectEntitlements($resource, $response);
         }
 
         return response()->json($response);
     }
 
     /**
      * Get a list of SKUs available to the resource.
      *
      * @param int $id Resource identifier
      *
      * @return \Illuminate\Http\JsonResponse
      */
     public function skus($id)
     {
         $resource = $this->model::find($id);
 
         if (!$this->checkTenant($resource)) {
             return $this->errorResponse(404);
         }
 
         if (!$this->guard()->user()->canRead($resource)) {
             return $this->errorResponse(403);
         }
 
         return API\V4\SkusController::objectSkus($resource);
     }
 
     /**
      * Fetch resource status (and reload setup process)
      *
      * @param int $id Resource identifier
      *
      * @return \Illuminate\Http\JsonResponse
      */
     public function status($id)
     {
         $resource = $this->model::find($id);
 
         if (!$this->checkTenant($resource)) {
             return $this->errorResponse(404);
         }
 
         if (!$this->guard()->user()->canRead($resource)) {
             return $this->errorResponse(403);
         }
 
         $response = $this->processStateUpdate($resource);
         $response = array_merge($response, $this->objectState($resource));
 
         return response()->json($response);
     }
 
     /**
      * Resource status (extended) information
      *
      * @param object $resource Resource object
      *
      * @return array Status information
      */
     public static function statusInfo($resource): array
     {
         return [];
     }
 }
diff --git a/src/app/Jobs/Resource/CreateJob.php b/src/app/Jobs/Resource/CreateJob.php
index 92e0fcd1..b51b7079 100644
--- a/src/app/Jobs/Resource/CreateJob.php
+++ b/src/app/Jobs/Resource/CreateJob.php
@@ -1,71 +1,80 @@
 <?php
 
 namespace App\Jobs\Resource;
 
 use App\Jobs\ResourceJob;
 
 class CreateJob extends ResourceJob
 {
     /**
      * Execute the job.
      *
      * @return void
      */
     public function handle()
     {
         $resource = $this->getResource();
 
         if (!$resource) {
             return;
         }
 
         // sanity checks
         if ($resource->isDeleted()) {
             $this->fail(new \Exception("Resource {$this->resourceId} is marked as deleted."));
             return;
         }
 
         if ($resource->trashed()) {
             $this->fail(new \Exception("Resource {$this->resourceId} is actually deleted."));
             return;
         }
 
         $withLdap = \config('app.with_ldap');
 
         // see if the domain is ready
         $domain = $resource->domain();
 
         if (!$domain) {
             $this->fail(new \Exception("The domain for resource {$this->resourceId} does not exist."));
             return;
         }
 
         if ($domain->isDeleted()) {
             $this->fail(new \Exception("The domain for resource {$this->resourceId} is marked as deleted."));
             return;
         }
 
         if ($withLdap && !$domain->isLdapReady()) {
             $this->release(60);
             return;
         }
 
         if ($withLdap && !$resource->isLdapReady()) {
             \App\Backends\LDAP::createResource($resource);
 
             $resource->status |= \App\Resource::STATUS_LDAP_READY;
             $resource->save();
         }
 
-        if (\config('app.with_imap') && !$resource->isImapReady()) {
-            if (!\App\Backends\IMAP::createResource($resource)) {
-                throw new \Exception("Failed to create mailbox for resource {$this->resourceId}.");
+        if (!$resource->isImapReady()) {
+            if (\config('app.with_imap')) {
+                if (!\App\Backends\IMAP::createResource($resource)) {
+                    throw new \Exception("Failed to create mailbox for resource {$this->resourceId}.");
+                }
+            } else {
+                $folder = $resource->getSetting('folder');
+
+                if ($folder && !\App\Backends\IMAP::verifySharedFolder($folder)) {
+                    $this->release(15);
+                    return;
+                }
             }
 
             $resource->status |= \App\Resource::STATUS_IMAP_READY;
         }
 
         $resource->status |= \App\Resource::STATUS_ACTIVE;
         $resource->save();
     }
 }
diff --git a/src/app/Jobs/Resource/DeleteJob.php b/src/app/Jobs/Resource/DeleteJob.php
index 9ffe9bbf..09543c1b 100644
--- a/src/app/Jobs/Resource/DeleteJob.php
+++ b/src/app/Jobs/Resource/DeleteJob.php
@@ -1,46 +1,48 @@
 <?php
 
 namespace App\Jobs\Resource;
 
 use App\Jobs\ResourceJob;
 
 class DeleteJob extends ResourceJob
 {
     /**
      * Execute the job.
      *
      * @return void
      */
     public function handle()
     {
         $resource = $this->getResource();
 
         if (!$resource) {
             return;
         }
 
         // sanity checks
         if ($resource->isDeleted()) {
             $this->fail(new \Exception("Resource {$this->resourceId} is already marked as deleted."));
             return;
         }
 
         if (\config('app.with_ldap') && $resource->isLdapReady()) {
             \App\Backends\LDAP::deleteResource($resource);
 
             $resource->status ^= \App\Resource::STATUS_LDAP_READY;
             $resource->save();
         }
 
-        if (\config('app.with_imap') && $resource->isImapReady()) {
-            if (!\App\Backends\IMAP::deleteResource($resource)) {
-                throw new \Exception("Failed to delete mailbox for resource {$this->resourceId}.");
+        if ($resource->isImapReady()) {
+            if (\config('app.with_imap')) {
+                if (!\App\Backends\IMAP::deleteResource($resource)) {
+                    throw new \Exception("Failed to delete mailbox for resource {$this->resourceId}.");
+                }
             }
 
             $resource->status ^= \App\Resource::STATUS_IMAP_READY;
         }
 
         $resource->status |= \App\Resource::STATUS_DELETED;
         $resource->save();
     }
 }
diff --git a/src/app/Jobs/SharedFolder/CreateJob.php b/src/app/Jobs/SharedFolder/CreateJob.php
index 0c44cb64..5b9c3320 100644
--- a/src/app/Jobs/SharedFolder/CreateJob.php
+++ b/src/app/Jobs/SharedFolder/CreateJob.php
@@ -1,72 +1,80 @@
 <?php
 
 namespace App\Jobs\SharedFolder;
 
 use App\Jobs\SharedFolderJob;
 
 class CreateJob extends SharedFolderJob
 {
     /**
      * Execute the job.
      *
      * @return void
      */
     public function handle()
     {
         $folder = $this->getSharedFolder();
 
         if (!$folder) {
             return;
         }
 
         // sanity checks
         if ($folder->isDeleted()) {
             $this->fail(new \Exception("Shared folder {$this->folderId} is marked as deleted."));
             return;
         }
 
         if ($folder->trashed()) {
             $this->fail(new \Exception("Shared folder {$this->folderId} is actually deleted."));
             return;
         }
 
         $withLdap = \config('app.with_ldap');
-        $withImap = \config('app.with_imap');
 
         // see if the domain is ready
         $domain = $folder->domain();
 
         if (!$domain) {
             $this->fail(new \Exception("The domain for shared folder {$this->folderId} does not exist."));
             return;
         }
 
         if ($domain->isDeleted()) {
             $this->fail(new \Exception("The domain for shared folder {$this->folderId} is marked as deleted."));
             return;
         }
 
         if ($withLdap && !$domain->isLdapReady()) {
             $this->release(60);
             return;
         }
 
         if ($withLdap && !$folder->isLdapReady()) {
             \App\Backends\LDAP::createSharedFolder($folder);
 
             $folder->status |= \App\SharedFolder::STATUS_LDAP_READY;
             $folder->save();
         }
 
-        if ($withImap && !$folder->isImapReady()) {
-            if (!\App\Backends\IMAP::createSharedFolder($folder)) {
-                throw new \Exception("Failed to create mailbox for shared folder {$this->folderId}.");
+        if (!$folder->isImapReady()) {
+            if (\config('app.with_imap')) {
+                if (!\App\Backends\IMAP::createSharedFolder($folder)) {
+                    throw new \Exception("Failed to create mailbox for shared folder {$this->folderId}.");
+                }
+            } else {
+                $folderName = $folder->getSetting('folder');
+
+                if ($folderName && !\App\Backends\IMAP::verifySharedFolder($folderName)) {
+                    $this->release(15);
+                    return;
+                }
             }
 
             $folder->status |= \App\SharedFolder::STATUS_IMAP_READY;
         }
 
         $folder->status |= \App\SharedFolder::STATUS_ACTIVE;
         $folder->save();
     }
 }
diff --git a/src/app/Jobs/SharedFolder/DeleteJob.php b/src/app/Jobs/SharedFolder/DeleteJob.php
index 8e4d5444..ef570888 100644
--- a/src/app/Jobs/SharedFolder/DeleteJob.php
+++ b/src/app/Jobs/SharedFolder/DeleteJob.php
@@ -1,47 +1,49 @@
 <?php
 
 namespace App\Jobs\SharedFolder;
 
 use App\Jobs\SharedFolderJob;
 
 class DeleteJob extends SharedFolderJob
 {
     /**
      * Execute the job.
      *
      * @return void
      */
     public function handle()
     {
         $folder = $this->getSharedFolder();
 
         if (!$folder) {
             return;
         }
 
         // sanity checks
         if ($folder->isDeleted()) {
             $this->fail(new \Exception("Shared folder {$this->folderId} is already marked as deleted."));
             return;
         }
 
         if (\config('app.with_ldap') && $folder->isLdapReady()) {
             \App\Backends\LDAP::deleteSharedFolder($folder);
 
             $folder->status ^= \App\SharedFolder::STATUS_LDAP_READY;
             // Already save in case of exception below
             $folder->save();
         }
 
         if ($folder->isImapReady()) {
-            if (!\App\Backends\IMAP::deleteSharedFolder($folder)) {
-                throw new \Exception("Failed to delete mailbox for shared folder {$this->folderId}.");
+            if (\config('app.with_imap')) {
+                if (!\App\Backends\IMAP::deleteSharedFolder($folder)) {
+                    throw new \Exception("Failed to delete mailbox for shared folder {$this->folderId}.");
+                }
             }
 
             $folder->status ^= \App\SharedFolder::STATUS_IMAP_READY;
         }
 
         $folder->status |= \App\SharedFolder::STATUS_DELETED;
         $folder->save();
     }
 }
diff --git a/src/app/Jobs/User/CreateJob.php b/src/app/Jobs/User/CreateJob.php
index f97117f6..4922cd38 100644
--- a/src/app/Jobs/User/CreateJob.php
+++ b/src/app/Jobs/User/CreateJob.php
@@ -1,107 +1,108 @@
 <?php
 
 namespace App\Jobs\User;
 
 use App\Jobs\UserJob;
 
 /**
  * Create the \App\User in LDAP.
  *
  * Throws exceptions for the following reasons:
  *
  *   * The user is marked as deleted (`$user->isDeleted()`), or
  *   * the user is actually deleted (`$user->deleted_at`), or
  *   * the user is already marked as ready in LDAP (`$user->isLdapReady()`).
  *
  */
 class CreateJob extends UserJob
 {
     /**
      * Execute the job.
      *
      * @return void
      *
      * @throws \Exception
      */
     public function handle()
     {
         $user = $this->getUser();
 
         if (!$user) {
             return;
         }
 
         if ($user->role) {
             // Admins/resellers don't reside in LDAP (for now)
             return;
         }
 
         if ($user->email == \config('imap.admin_login')) {
             // Ignore Cyrus admin account
             return;
         }
 
         // sanity checks
         if ($user->isDeleted()) {
             $this->fail(new \Exception("User {$this->userId} is marked as deleted."));
             return;
         }
 
         if ($user->trashed()) {
             $this->fail(new \Exception("User {$this->userId} is actually deleted."));
             return;
         }
 
         $withLdap = \config('app.with_ldap');
 
         // see if the domain is ready
         $domain = $user->domain();
 
         if (!$domain) {
             $this->fail(new \Exception("The domain for {$this->userId} does not exist."));
             return;
         }
 
         if ($domain->isDeleted()) {
             $this->fail(new \Exception("The domain for {$this->userId} is marked as deleted."));
             return;
         }
 
         if ($withLdap && !$domain->isLdapReady()) {
             $this->release(60);
             return;
         }
 
-        if (\config('abuse.suspend_enabled')) {
+        if (\config('abuse.suspend_enabled') && !$user->isSuspended()) {
             $code = \Artisan::call("user:abuse-check {$this->userId}");
             if ($code == 2) {
                 \Log::info("Suspending user due to suspected abuse: {$this->userId} {$user->email}");
                 $user->status |= \App\User::STATUS_SUSPENDED;
             }
         }
 
         if ($withLdap && !$user->isLdapReady()) {
             \App\Backends\LDAP::createUser($user);
 
             $user->status |= \App\User::STATUS_LDAP_READY;
             $user->save();
         }
 
         if (!$user->isImapReady()) {
             if (\config('app.with_imap')) {
                 if (!\App\Backends\IMAP::createUser($user)) {
                     throw new \Exception("Failed to create mailbox for user {$this->userId}.");
                 }
             } else {
                 if (!\App\Backends\IMAP::verifyAccount($user->email)) {
-                    throw new \Exception("Failed to find the mailbox for user {$this->userId}.");
+                    $this->release(15);
+                    return;
                 }
             }
 
             $user->status |= \App\User::STATUS_IMAP_READY;
         }
 
         $user->status |= \App\User::STATUS_ACTIVE;
         $user->save();
     }
 }
diff --git a/src/app/Observers/SignupCodeObserver.php b/src/app/Observers/SignupCodeObserver.php
index 96c0fb8a..23c3900b 100644
--- a/src/app/Observers/SignupCodeObserver.php
+++ b/src/app/Observers/SignupCodeObserver.php
@@ -1,77 +1,77 @@
 <?php
 
 namespace App\Observers;
 
 use App\SignupCode;
 use Carbon\Carbon;
 use Illuminate\Support\Str;
 
 class SignupCodeObserver
 {
     /**
      * Handle the "creating" event.
      *
      * Ensure that the code entry is created with a random code/short_code.
      *
      * @param \App\SignupCode $code The code being created.
      *
      * @return void
      */
     public function creating(SignupCode $code): void
     {
         $code_length = SignupCode::CODE_LENGTH;
         $exp_hours   = env('SIGNUP_CODE_EXPIRY', SignupCode::CODE_EXP_HOURS);
 
         if (empty($code->code)) {
             $code->short_code = SignupCode::generateShortCode();
 
             // FIXME: Replace this with something race-condition free
             while (true) {
                 $code->code = Str::random($code_length);
                 if (!SignupCode::find($code->code)) {
                     break;
                 }
             }
         }
 
         $code->headers = collect(request()->headers->all())
             ->filter(function ($value, $key) {
                 // remove some headers we don't care about
                 return !in_array($key, ['cookie', 'referer', 'x-test-payment-provider', 'origin']);
             })
             ->map(function ($value) {
                 return is_array($value) && count($value) == 1 ? $value[0] : $value;
             })
             ->all();
 
         $code->expires_at = Carbon::now()->addHours($exp_hours);
         $code->ip_address = request()->ip();
 
         if ($code->email && strpos($code->email, '@')) {
             $parts = explode('@', $code->email);
 
             $code->local_part = $parts[0];
             $code->domain_part = $parts[1];
         }
     }
 
     /**
      * Handle the "updating" event.
      *
      * @param SignupCode $code The code being updated.
      *
      * @return void
      */
     public function updating(SignupCode $code)
     {
-        if ($code->email) {
+        if ($code->email && strpos($code->email, '@')) {
             $parts = explode('@', $code->email);
 
             $code->local_part = $parts[0];
             $code->domain_part = $parts[1];
         } else {
             $code->local_part = null;
             $code->domain_part = null;
         }
     }
 }
diff --git a/src/app/Traits/EmailPropertyTrait.php b/src/app/Traits/EmailPropertyTrait.php
index 640f2ed4..00416eac 100644
--- a/src/app/Traits/EmailPropertyTrait.php
+++ b/src/app/Traits/EmailPropertyTrait.php
@@ -1,92 +1,94 @@
 <?php
 
 namespace App\Traits;
 
 trait EmailPropertyTrait
 {
     /** @var ?string Domain name for the to-be-created object */
     public $domainName;
 
 
     /**
      * Boot function from Laravel.
      */
     protected static function bootEmailPropertyTrait()
     {
         static::creating(function ($model) {
             if (empty($model->email) && defined('static::EMAIL_TEMPLATE')) {
                 $template = static::EMAIL_TEMPLATE; // @phpstan-ignore-line
                 $defaults = [
                     'type' => 'mail',
                 ];
 
                 foreach (['id', 'domainName', 'type'] as $prop) {
                     if (strpos($template, "{{$prop}}") === false) {
                         continue;
                     }
 
                     $value = $model->{$prop} ?? ($defaults[$prop] ?? '');
 
                     if ($value === '' || $value === null) {
                         throw new \Exception("Missing '{$prop}' property for " . static::class);
                     }
 
                     $template = str_replace("{{$prop}}", $value, $template);
                 }
 
                 $model->email = strtolower($template);
             }
         });
     }
 
     /**
      * Returns the object's domain (including soft-deleted).
      *
      * @return ?\App\Domain The domain to which the object belongs to, NULL if it does not exist
      */
     public function domain(): ?\App\Domain
     {
         if (empty($this->email) && isset($this->domainName)) {
             $domainName = $this->domainName;
-        } else {
+        } else if (strpos($this->email, '@')) {
             list($local, $domainName) = explode('@', $this->email);
+        } else {
+            return null;
         }
 
         return \App\Domain::withTrashed()->where('namespace', $domainName)->first();
     }
 
     /**
      * Find whether an email address exists as a model object (including soft-deleted).
      *
      * @param string $email         Email address
      * @param bool   $return_object Return model instance instead of a boolean
      *
      * @return static|bool True or Model object if found, False otherwise
      */
     public static function emailExists(string $email, bool $return_object = false)
     {
         if (strpos($email, '@') === false) {
             return false;
         }
 
         $email = \strtolower($email);
 
         $object = static::withTrashed()->where('email', $email)->first();
 
         if ($object) {
             return $return_object ? $object : true;
         }
 
         return false;
     }
 
     /**
      * Ensure the email is appropriately cased.
      *
      * @param string $email Email address
      */
     public function setEmailAttribute(string $email): void
     {
         $this->attributes['email'] = strtolower($email);
     }
 }
diff --git a/src/resources/vue/Widgets/Status.vue b/src/resources/vue/Widgets/Status.vue
index bebc7845..79688ea1 100644
--- a/src/resources/vue/Widgets/Status.vue
+++ b/src/resources/vue/Widgets/Status.vue
@@ -1,204 +1,204 @@
 <template>
-    <div v-if="!state.isReady" id="status-box" :class="'p-4 mb-3 rounded process-' + className">
+    <div v-if="!state.isDone" id="status-box" :class="'p-4 mb-3 rounded process-' + className">
         <div v-if="state.step != 'domain-confirmed'" class="d-flex align-items-start">
             <p id="status-body" class="flex-grow-1">
                 <span>{{ $t('status.prepare-' + scopeLabel()) }}</span>
                 <br>
                 {{ $t('status.prepare-hint') }}
                 <br>
                 <span id="refresh-text" v-if="refresh">{{ $t('status.prepare-refresh') }}</span>
             </p>
             <btn v-if="refresh" id="status-refresh" href="#" class="btn-secondary" @click="statusRefresh" icon="rotate">
                 {{ $t('btn.refresh') }}
             </btn>
         </div>
         <div v-else class="d-flex align-items-start">
             <p id="status-body" class="flex-grow-1">
                 <span>{{ $t('status.ready-' + scopeLabel()) }}</span>
                 <br>
                 {{ $t('status.verify') }}
             </p>
             <div v-if="scope == 'domain'">
                 <btn id="status-verify" class="btn-secondary text-nowrap" @click="confirmDomain" icon="rotate">
                     {{ $t('btn.verify') }}
                 </btn>
             </div>
             <div v-else-if="state.link && scope != 'domain'">
                 <router-link id="status-link" class="btn btn-secondary" :to="{ path: state.link }">{{ $t('status.verify-domain') }}</router-link>
             </div>
         </div>
 
         <div class="status-progress text-center">
             <div class="progress">
                 <div class="progress-bar" role="progressbar" aria-valuenow="0" aria-valuemin="0" aria-valuemax="100"></div>
             </div>
             <span class="progress-label">{{ state.title || $t('msg.initializing') }}</span>
         </div>
     </div>
 </template>
 
 <script>
     import { library } from '@fortawesome/fontawesome-svg-core'
 
     library.add(
         require('@fortawesome/free-solid-svg-icons/faRotate').definition,
     )
 
     export default {
         props: {
             status: { type: Object, default: () => {} }
         },
         data() {
             return {
                 className: 'pending',
                 refresh: false,
                 delay: 5000,
                 scope: 'user',
-                state: { isReady: true },
+                state: { isDone: true },
                 waiting: 0,
             }
         },
         watch: {
             // We use property watcher because parent component
             // might set the property with a delay and we need to parse it
             // FIXME: Problem with this and update-status event is that whenever
             //        we emit the event a watcher function is executed, causing
             //        duplicate parseStatusInfo() calls. Fortunaltely this does not
             //        cause duplicate http requests.
             status: function (val, oldVal) {
                 this.parseStatusInfo(val)
             }
         },
         destroyed() {
             clearTimeout(window.infoRequest)
         },
         mounted() {
             this.scope = this.$route.name
         },
         methods: {
             // Displays account status information
             parseStatusInfo(info) {
                 if (info) {
-                    if (!info.isReady) {
+                    if (!info.isDone) {
                         let failedCount = 0
                         let allCount = info.process.length
 
                         info.process.forEach((step, idx) => {
                             if (!step.state) {
                                 failedCount++
 
                                 if (!info.title) {
                                     info.title = step.title
                                     info.step = step.label
                                     info.link = step.link
                                 }
                             }
                         })
 
                         info.percent = Math.floor((allCount - failedCount) / allCount * 100);
                     }
 
                     this.state = info || {}
 
                     this.$nextTick(function() {
                         $(this.$el).find('.progress-bar')
                             .css('width', info.percent + '%')
                             .attr('aria-valuenow', info.percent)
                     })
 
                     // Unhide the Refresh button, the process is in failure state
                     this.refresh = info.processState == 'failed' && this.waiting == 0
 
                     if (this.refresh || info.step == 'domain-confirmed') {
                         this.className = 'failed'
                     }
 
                     // A async job has been dispatched, switch to a waiting mode where
                     // we hide the Refresh button and pull status for about a minute,
                     // after that we switch to normal mode, i.e. user can Refresh again (if still not ready)
                     if (info.processState == 'waiting') {
                         this.waiting = 10
                         this.delay = 5000
                     } else if (this.waiting > 0) {
                         this.waiting -= 1
                     }
                 }
 
                 // Update status process info every 5,6,7,8,9,... seconds
                 clearTimeout(window.infoRequest)
-                if ((!this.refresh || this.waiting > 0) && (!info || !info.isReady)) {
+                if ((!this.refresh || this.waiting > 0) && (!info || !info.isDone)) {
                     window.infoRequest = setTimeout(() => {
                         delete window.infoRequest
                         // Stop updates after user logged out
                         if (!this.$root.authInfo) {
                             return;
                         }
 
                         axios.get(this.getUrl())
                             .then(response => {
                                 this.parseStatusInfo(response.data)
                                 this.emitEvent(response.data)
                             })
                             .catch(error => {
                                 this.parseStatusInfo(info)
                             })
                     }, this.delay);
 
                     this.delay += 1000;
                 }
             },
             statusRefresh() {
                 clearTimeout(window.infoRequest)
 
                 axios.get(this.getUrl() + '?refresh=1')
                     .then(response => {
                         this.$toast[response.data.status](response.data.message)
                         this.parseStatusInfo(response.data)
                         this.emitEvent(response.data)
                     })
                     .catch(error => {
                         this.parseStatusInfo(this.state)
                     })
             },
             confirmDomain() {
                 axios.get('/api/v4/domains/' + this.$route.params.domain + '/confirm')
                     .then(response => {
                         if (response.data.message) {
                             this.$toast[response.data.status](response.data.message)
                         }
 
                         if (response.data.status == 'success') {
                             this.parseStatusInfo(response.data.statusInfo)
                             response.data.isConfirmed = true
                             this.emitEvent(response.data)
                         }
                     })
             },
             emitEvent(data) {
                 // Remove useless data and emit the event (to parent components)
                 delete data.status
                 delete data.message
                 this.$emit('status-update', data)
             },
             getUrl() {
                 let scope = this.scope
                 let id = this.$route.params[scope]
 
                 if (scope == 'dashboard') {
                     id = this.$root.authInfo.id
                     scope = 'user'
                 } else if (scope =='distlist') {
                     id = this.$route.params.list
                     scope = 'group'
                 } else if (scope == 'shared-folder') {
                     id = this.$route.params.folder
                 }
 
                 return '/api/v4/' + scope + 's/' + id + '/status'
             },
             scopeLabel() {
                 return this.scope == 'dashboard' ? 'account' : this.scope
             }
         }
     }
 </script>
diff --git a/src/tests/Browser/StatusTest.php b/src/tests/Browser/StatusTest.php
index 5897dc92..23e096a2 100644
--- a/src/tests/Browser/StatusTest.php
+++ b/src/tests/Browser/StatusTest.php
@@ -1,287 +1,287 @@
 <?php
 
 namespace Tests\Browser;
 
 use App\Domain;
 use App\User;
 use Carbon\Carbon;
 use Tests\Browser;
 use Tests\Browser\Components\Status;
 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\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();
 
         $domain_status = Domain::STATUS_CONFIRMED | Domain::STATUS_VERIFIED;
         DB::statement("UPDATE domains SET status = (status | {$domain_status})"
             . " WHERE namespace = 'kolab.org'");
-        DB::statement("UPDATE users SET status = (status | " . User::STATUS_IMAP_READY . ")"
+        DB::statement("UPDATE users SET status = (status | " . (User::STATUS_IMAP_READY | User::STATUS_LDAP_READY) . ")"
             . " WHERE email = 'john@kolab.org'");
     }
 
     /**
      * {@inheritDoc}
      */
     public function tearDown(): void
     {
         $domain_status = Domain::STATUS_CONFIRMED | Domain::STATUS_VERIFIED;
         DB::statement("UPDATE domains SET status = (status | {$domain_status})"
             . " 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 and user
         $domain = Domain::where('namespace', 'kolab.org')->first();
 
         if ($domain->isConfirmed()) {
             $domain->status ^= Domain::STATUS_CONFIRMED;
             $domain->save();
         }
 
         $john = $this->getTestUser('john@kolab.org');
 
         $john->created_at = Carbon::now();
 
         if ($john->isImapReady()) {
             $john->status ^= User::STATUS_IMAP_READY;
         }
 
         $john->save();
 
         $this->browse(function ($browser) use ($john, $domain) {
             $browser->visit(new Home())
                 ->submitLogon('john@kolab.org', 'simple123', true)
                 ->on(new Dashboard())
                 ->with(new Status(), function ($browser) use ($john) {
                     $browser->assertSeeIn('@body', 'We are preparing your account')
                         ->assertProgress(71, 'Creating a mailbox...', 'pending')
                         ->assertMissing('#status-verify')
                         ->assertMissing('#status-link')
                         ->assertMissing('@refresh-button')
                         ->assertMissing('@refresh-text');
 
                     $john->status |= User::STATUS_IMAP_READY;
                     $john->save();
 
                     // Wait for auto-refresh, expect domain-confirmed step
                     $browser->pause(6000)
                         ->assertSeeIn('@body', 'Your account is almost ready')
                         ->assertProgress(85, 'Verifying an ownership of a custom domain...', 'failed')
                         ->assertMissing('@refresh-button')
                         ->assertMissing('@refresh-text')
                         ->assertMissing('#status-verify')
                         ->assertVisible('#status-link');
                 })
                 // check if the link to domain info page works
                 ->click('#status-link')
                 ->on(new DomainInfo())
                 ->back()
                 ->on(new Dashboard())
                 ->with(new Status(), function ($browser) {
                     $browser->assertMissing('@refresh-button')
                         ->assertProgress(85, 'Verifying an ownership of a custom domain...', 'failed');
                 });
 
             // Confirm the domain and wait until the whole status box disappears
             $domain->status |= Domain::STATUS_CONFIRMED;
             $domain->save();
 
             // This should take less than 10 seconds
             $browser->waitUntilMissing('@status', 10);
         });
 
         // Test the Refresh button
         if ($domain->isConfirmed()) {
             $domain->status ^= Domain::STATUS_CONFIRMED;
             $domain->save();
         }
 
         $john->created_at = Carbon::now()->subSeconds(3600);
 
         if ($john->isImapReady()) {
             $john->status ^= User::STATUS_IMAP_READY;
         }
 
         $john->save();
 
         $this->browse(function ($browser) use ($john, $domain) {
             $browser->visit(new Dashboard())
                 ->with(new Status(), function ($browser) use ($john, $domain) {
                     $browser->assertSeeIn('@body', 'We are preparing your account')
                         ->assertProgress(71, 'Creating a mailbox...', 'failed')
                         ->assertVisible('@refresh-button')
                         ->assertVisible('@refresh-text');
 
                     $browser->click('@refresh-button')
                         ->assertToast(Toast::TYPE_SUCCESS, 'Setup process has been pushed. Please wait.');
 
                     $john->status |= User::STATUS_IMAP_READY;
                     $john->save();
                     $domain->status |= Domain::STATUS_CONFIRMED;
                     $domain->save();
                 })
                 ->waitUntilMissing('@status', 10);
         });
     }
 
     /**
      * Test domain status on domains list and domain info page
      *
      * @depends testDashboard
      */
     public function testDomainStatus(): void
     {
         $domain = Domain::where('namespace', 'kolab.org')->first();
         $domain->created_at = Carbon::now();
         $domain->status = Domain::STATUS_NEW | Domain::STATUS_ACTIVE | Domain::STATUS_LDAP_READY;
         $domain->save();
 
         // side-step
         $this->assertFalse($domain->isNew());
         $this->assertTrue($domain->isActive());
         $this->assertTrue($domain->isLdapReady());
         $this->assertTrue($domain->isExternal());
 
         $this->assertFalse($domain->isHosted());
         $this->assertFalse($domain->isConfirmed());
         $this->assertFalse($domain->isVerified());
         $this->assertFalse($domain->isSuspended());
         $this->assertFalse($domain->isDeleted());
 
         $this->browse(function ($browser) use ($domain) {
             // Test auto-refresh
             $browser->on(new Dashboard())
                 ->click('@links a.link-domains')
                 ->on(new DomainList())
                 ->waitFor('@table tbody tr')
                 // 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())
                 ->with(new Status(), function ($browser) {
                     $browser->assertSeeIn('@body', 'We are preparing the domain')
                         ->assertProgress(50, 'Verifying a custom domain...', 'pending')
                         ->assertMissing('@refresh-button')
                         ->assertMissing('@refresh-text')
                         ->assertMissing('#status-link')
                         ->assertMissing('#status-verify');
                 });
 
             $domain->status |= Domain::STATUS_VERIFIED;
             $domain->save();
 
             // This should take less than 10 seconds
             $browser->waitFor('@status.process-failed')
                 ->with(new Status(), function ($browser) {
                     $browser->assertSeeIn('@body', 'The domain is almost ready')
                         ->assertProgress(75, 'Verifying an ownership of a custom domain...', 'failed')
                         ->assertMissing('@refresh-button')
                         ->assertMissing('@refresh-text')
                         ->assertMissing('#status-link')
                         ->assertVisible('#status-verify');
                 });
 
             $domain->status |= Domain::STATUS_CONFIRMED;
             $domain->save();
 
             // Test Verify button
             $browser->click('@status #status-verify')
                 ->assertToast(Toast::TYPE_SUCCESS, 'Domain verified successfully.')
                 ->waitUntilMissing('@status')
                 ->waitUntilMissing('@verify')
                 ->assertVisible('@config');
         });
     }
 
     /**
      * Test user status on users list and user info page
      *
      * @depends testDashboard
      */
     public function testUserStatus(): void
     {
         $john = $this->getTestUser('john@kolab.org');
         $john->created_at = Carbon::now();
         if ($john->isImapReady()) {
             $john->status ^= User::STATUS_IMAP_READY;
         }
         $john->save();
 
         $domain = Domain::where('namespace', 'kolab.org')->first();
         if ($domain->isConfirmed()) {
             $domain->status ^= Domain::STATUS_CONFIRMED;
             $domain->save();
         }
 
         $this->browse(function ($browser) use ($john, $domain) {
             $browser->visit(new Dashboard())
                 ->click('@links a.link-users')
                 ->on(new UserList())
                 ->waitFor('@table tbody tr')
                 // 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(3) td:first-child svg.fa-user.text-danger')
                 ->assertText('@table tbody tr:nth-child(3) td:first-child svg title', 'Not Ready')
                 ->click('@table tbody tr:nth-child(3) td:first-child a')
                 ->on(new UserInfo())
                 ->with('@form', function (Browser $browser) {
                     // Assert state in the user edit form
                     $browser->assertSeeIn('div.row:nth-child(1) label', 'Status')
                         ->assertSeeIn('div.row:nth-child(1) #status', 'Not Ready');
                 })
                 ->with(new Status(), function ($browser) use ($john) {
                     $browser->assertSeeIn('@body', 'We are preparing the user account')
                         ->assertProgress(71, 'Creating a mailbox...', 'pending')
                         ->assertMissing('#status-verify')
                         ->assertMissing('#status-link')
                         ->assertMissing('@refresh-button')
                         ->assertMissing('@refresh-text');
 
 
                     $john->status |= User::STATUS_IMAP_READY;
                     $john->save();
 
                     // Wait for auto-refresh, expect domain-confirmed step
                     $browser->pause(6000)
                         ->assertSeeIn('@body', 'The user account is almost ready')
                         ->assertProgress(85, 'Verifying an ownership of a custom domain...', 'failed')
                         ->assertMissing('@refresh-button')
                         ->assertMissing('@refresh-text')
                         ->assertMissing('#status-verify')
                         ->assertVisible('#status-link');
                 })
                 ->assertSeeIn('#status', 'Active');
 
             // Confirm the domain and wait until the whole status box disappears
             $domain->status |= Domain::STATUS_CONFIRMED;
             $domain->save();
 
             // This should take less than 10 seconds
             $browser->waitUntilMissing('@status', 10);
         });
     }
 }
diff --git a/src/tests/Feature/Controller/DomainsTest.php b/src/tests/Feature/Controller/DomainsTest.php
index 1e417fb6..2ab062c0 100644
--- a/src/tests/Feature/Controller/DomainsTest.php
+++ b/src/tests/Feature/Controller/DomainsTest.php
@@ -1,618 +1,620 @@
 <?php
 
 namespace Tests\Feature\Controller;
 
 use App\Domain;
 use App\Entitlement;
 use App\Sku;
 use App\Tenant;
 use App\User;
 use App\Wallet;
 use Illuminate\Support\Facades\Queue;
 use Illuminate\Support\Str;
 use Tests\TestCase;
 
 class DomainsTest extends TestCase
 {
     /**
      * {@inheritDoc}
      */
     public function setUp(): void
     {
         parent::setUp();
 
         $this->deleteTestUser('test1@' . \config('app.domain'));
         $this->deleteTestUser('test2@' . \config('app.domain'));
         $this->deleteTestUser('test1@domainscontroller.com');
         $this->deleteTestDomain('domainscontroller.com');
         Sku::where('title', 'test')->delete();
     }
 
     public function tearDown(): void
     {
         $this->deleteTestUser('test1@' . \config('app.domain'));
         $this->deleteTestUser('test2@' . \config('app.domain'));
         $this->deleteTestUser('test1@domainscontroller.com');
         $this->deleteTestDomain('domainscontroller.com');
         Sku::where('title', 'test')->delete();
 
         $domain = $this->getTestDomain('kolab.org');
         $domain->settings()->whereIn('key', ['spf_whitelist'])->delete();
 
         parent::tearDown();
     }
 
     /**
      * Test domain confirm request
      * @group skipci
      */
     public function testConfirm(): void
     {
         Queue::fake();
 
         $sku_domain = Sku::withEnvTenantContext()->where('title', 'domain-hosting')->first();
         $john = $this->getTestUser('john@kolab.org');
         $ned = $this->getTestUser('ned@kolab.org');
         $user = $this->getTestUser('test1@domainscontroller.com');
         $domain = $this->getTestDomain('domainscontroller.com', [
                 'status' => Domain::STATUS_NEW,
                 'type' => Domain::TYPE_EXTERNAL,
         ]);
 
         Entitlement::create([
                 'wallet_id' => $user->wallets()->first()->id,
                 'sku_id' => $sku_domain->id,
                 'entitleable_id' => $domain->id,
                 'entitleable_type' => Domain::class
         ]);
 
         $response = $this->actingAs($user)->get("api/v4/domains/{$domain->id}/confirm");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertCount(2, $json);
         $this->assertEquals('error', $json['status']);
         $this->assertEquals('Domain ownership verification failed.', $json['message']);
 
         $domain->status |= Domain::STATUS_CONFIRMED;
         $domain->save();
 
         $response = $this->actingAs($user)->get("api/v4/domains/{$domain->id}/confirm");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertEquals('success', $json['status']);
         $this->assertEquals('Domain verified successfully.', $json['message']);
         $this->assertTrue(is_array($json['statusInfo']));
 
         // Not authorized access
         $response = $this->actingAs($john)->get("api/v4/domains/{$domain->id}/confirm");
         $response->assertStatus(403);
 
         // Authorized access by additional account controller
         $domain = $this->getTestDomain('kolab.org');
         $response = $this->actingAs($ned)->get("api/v4/domains/{$domain->id}/confirm");
         $response->assertStatus(200);
     }
 
     /**
      * Test domain delete request (DELETE /api/v4/domains/<id>)
      */
     public function testDestroy(): void
     {
         Queue::fake();
 
         $sku_domain = Sku::withEnvTenantContext()->where('title', 'domain-hosting')->first();
         $john = $this->getTestUser('john@kolab.org');
         $johns_domain = $this->getTestDomain('kolab.org');
         $user1 = $this->getTestUser('test1@' . \config('app.domain'));
         $user2 = $this->getTestUser('test2@' . \config('app.domain'));
         $domain = $this->getTestDomain('domainscontroller.com', [
                 'status' => Domain::STATUS_NEW,
                 'type' => Domain::TYPE_EXTERNAL,
         ]);
 
         Entitlement::create([
                 'wallet_id' => $user1->wallets()->first()->id,
                 'sku_id' => $sku_domain->id,
                 'entitleable_id' => $domain->id,
                 'entitleable_type' => Domain::class
         ]);
 
         // Not authorized access
         $response = $this->actingAs($john)->delete("api/v4/domains/{$domain->id}");
         $response->assertStatus(403);
 
         // Can't delete non-empty domain
         $response = $this->actingAs($john)->delete("api/v4/domains/{$johns_domain->id}");
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertCount(2, $json);
         $this->assertEquals('error', $json['status']);
         $this->assertEquals('Unable to delete a domain with assigned users or other objects.', $json['message']);
 
         // Successful deletion
         $response = $this->actingAs($user1)->delete("api/v4/domains/{$domain->id}");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertCount(2, $json);
         $this->assertEquals('success', $json['status']);
         $this->assertEquals('Domain deleted successfully.', $json['message']);
         $this->assertTrue($domain->fresh()->trashed());
 
         // Authorized access by additional account controller
         $this->deleteTestDomain('domainscontroller.com');
         $domain = $this->getTestDomain('domainscontroller.com', [
                 'status' => Domain::STATUS_NEW,
                 'type' => Domain::TYPE_EXTERNAL,
         ]);
 
         Entitlement::create([
                 'wallet_id' => $user1->wallets()->first()->id,
                 'sku_id' => $sku_domain->id,
                 'entitleable_id' => $domain->id,
                 'entitleable_type' => Domain::class
         ]);
 
         $user1->wallets()->first()->addController($user2);
 
         $response = $this->actingAs($user2)->delete("api/v4/domains/{$domain->id}");
         $response->assertStatus(200);
 
         $json = $response->json();
         $this->assertCount(2, $json);
         $this->assertEquals('success', $json['status']);
         $this->assertEquals('Domain deleted successfully.', $json['message']);
         $this->assertTrue($domain->fresh()->trashed());
     }
 
     /**
      * Test fetching domains list
      */
     public function testIndex(): void
     {
         // User with no domains
         $user = $this->getTestUser('test1@domainscontroller.com');
         $response = $this->actingAs($user)->get("api/v4/domains");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertCount(4, $json);
         $this->assertSame(0, $json['count']);
         $this->assertSame(false, $json['hasMore']);
         $this->assertSame("0 domains have been found.", $json['message']);
         $this->assertSame([], $json['list']);
 
         // User with custom domain(s)
         $john = $this->getTestUser('john@kolab.org');
         $ned = $this->getTestUser('ned@kolab.org');
 
         $response = $this->actingAs($john)->get("api/v4/domains");
         $response->assertStatus(200);
 
         $json = $response->json();
         $this->assertCount(4, $json);
         $this->assertSame(1, $json['count']);
         $this->assertSame(false, $json['hasMore']);
         $this->assertSame("1 domains have been found.", $json['message']);
         $this->assertCount(1, $json['list']);
         $this->assertSame('kolab.org', $json['list'][0]['namespace']);
         // Values below are tested by Unit tests
         $this->assertArrayHasKey('isConfirmed', $json['list'][0]);
         $this->assertArrayHasKey('isDeleted', $json['list'][0]);
         $this->assertArrayHasKey('isVerified', $json['list'][0]);
         $this->assertArrayHasKey('isSuspended', $json['list'][0]);
         $this->assertArrayHasKey('isActive', $json['list'][0]);
         if (\config('app.with_ldap')) {
             $this->assertArrayHasKey('isLdapReady', $json['list'][0]);
         } else {
             $this->assertArrayNotHasKey('isLdapReady', $json['list'][0]);
         }
         $this->assertArrayHasKey('isReady', $json['list'][0]);
 
         $response = $this->actingAs($ned)->get("api/v4/domains");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertCount(4, $json);
         $this->assertCount(1, $json['list']);
         $this->assertSame('kolab.org', $json['list'][0]['namespace']);
     }
 
     /**
      * Test domain config update (POST /api/v4/domains/<domain>/config)
      */
     public function testSetConfig(): void
     {
         $john = $this->getTestUser('john@kolab.org');
         $jack = $this->getTestUser('jack@kolab.org');
         $domain = $this->getTestDomain('kolab.org');
         $domain->setSetting('spf_whitelist', null);
 
         // Test unknown domain id
         $post = ['spf_whitelist' => []];
         $response = $this->actingAs($john)->post("/api/v4/domains/123/config", $post);
         $json = $response->json();
 
         $response->assertStatus(404);
 
         // Test access by user not being a wallet controller
         $post = ['spf_whitelist' => []];
         $response = $this->actingAs($jack)->post("/api/v4/domains/{$domain->id}/config", $post);
         $json = $response->json();
 
         $response->assertStatus(403);
 
         $this->assertSame('error', $json['status']);
         $this->assertSame("Access denied", $json['message']);
         $this->assertCount(2, $json);
 
         // Test some invalid data
         $post = ['grey' => 1];
         $response = $this->actingAs($john)->post("/api/v4/domains/{$domain->id}/config", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(2, $json);
         $this->assertCount(1, $json['errors']);
         $this->assertSame('The requested configuration parameter is not supported.', $json['errors']['grey']);
 
         $this->assertNull($domain->fresh()->getSetting('spf_whitelist'));
 
         // Test some valid data
         $post = ['spf_whitelist' => ['.test.domain.com']];
         $response = $this->actingAs($john)->post("/api/v4/domains/{$domain->id}/config", $post);
 
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertCount(2, $json);
         $this->assertSame('success', $json['status']);
         $this->assertSame('Domain settings updated successfully.', $json['message']);
 
         $expected = \json_encode($post['spf_whitelist']);
         $this->assertSame($expected, $domain->fresh()->getSetting('spf_whitelist'));
 
         // Test input validation
         $post = ['spf_whitelist' => ['aaa']];
         $response = $this->actingAs($john)->post("/api/v4/domains/{$domain->id}/config", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertCount(2, $json);
         $this->assertSame('error', $json['status']);
         $this->assertCount(1, $json['errors']);
         $this->assertSame(
             'The entry format is invalid. Expected a domain name starting with a dot.',
             $json['errors']['spf_whitelist'][0]
         );
 
         $this->assertSame($expected, $domain->fresh()->getSetting('spf_whitelist'));
     }
 
     /**
      * Test fetching domain info
      */
     public function testShow(): void
     {
         $sku_domain = Sku::withEnvTenantContext()->where('title', 'domain-hosting')->first();
         $user = $this->getTestUser('test1@domainscontroller.com');
         $domain = $this->getTestDomain('domainscontroller.com', [
                 'status' => Domain::STATUS_NEW,
                 'type' => Domain::TYPE_EXTERNAL,
         ]);
 
         $discount = \App\Discount::withEnvTenantContext()->where('code', 'TEST')->first();
         $wallet = $user->wallet();
         $wallet->discount()->associate($discount);
         $wallet->save();
 
         Entitlement::create([
                 'wallet_id' => $user->wallets()->first()->id,
                 'sku_id' => $sku_domain->id,
                 'entitleable_id' => $domain->id,
                 'entitleable_type' => Domain::class
         ]);
 
         $response = $this->actingAs($user)->get("api/v4/domains/{$domain->id}");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertEquals($domain->id, $json['id']);
         $this->assertEquals($domain->namespace, $json['namespace']);
         $this->assertEquals($domain->status, $json['status']);
         $this->assertEquals($domain->type, $json['type']);
         $this->assertSame($domain->hash(Domain::HASH_TEXT), $json['hash_text']);
         $this->assertSame($domain->hash(Domain::HASH_CNAME), $json['hash_cname']);
         $this->assertSame($domain->hash(Domain::HASH_CODE), $json['hash_code']);
         $this->assertSame([], $json['config']['spf_whitelist']);
         $this->assertCount(4, $json['mx']);
         $this->assertTrue(strpos(implode("\n", $json['mx']), $domain->namespace) !== false);
         $this->assertCount(8, $json['dns']);
         $this->assertTrue(strpos(implode("\n", $json['dns']), $domain->namespace) !== false);
         $this->assertTrue(strpos(implode("\n", $json['dns']), $domain->hash()) !== false);
         $this->assertTrue(is_array($json['statusInfo']));
         // Values below are tested by Unit tests
         $this->assertArrayHasKey('isConfirmed', $json);
         $this->assertArrayHasKey('isDeleted', $json);
         $this->assertArrayHasKey('isVerified', $json);
         $this->assertArrayHasKey('isSuspended', $json);
         $this->assertArrayHasKey('isActive', $json);
         if (\config('app.with_ldap')) {
             $this->assertArrayHasKey('isLdapReady', $json);
         } else {
             $this->assertArrayNotHasKey('isLdapReady', $json);
         }
         $this->assertArrayHasKey('isReady', $json);
         $this->assertCount(1, $json['skus']);
         $this->assertSame(1, $json['skus'][$sku_domain->id]['count']);
         $this->assertSame([0], $json['skus'][$sku_domain->id]['costs']);
         $this->assertSame($wallet->id, $json['wallet']['id']);
         $this->assertSame($wallet->balance, $json['wallet']['balance']);
         $this->assertSame($wallet->currency, $json['wallet']['currency']);
         $this->assertSame($discount->discount, $json['wallet']['discount']);
         $this->assertSame($discount->description, $json['wallet']['discount_description']);
 
         $john = $this->getTestUser('john@kolab.org');
         $ned = $this->getTestUser('ned@kolab.org');
         $jack = $this->getTestUser('jack@kolab.org');
 
         // Not authorized - Other account domain
         $response = $this->actingAs($john)->get("api/v4/domains/{$domain->id}");
         $response->assertStatus(403);
 
         $domain = $this->getTestDomain('kolab.org');
 
         // Ned is an additional controller on kolab.org's wallet
         $response = $this->actingAs($ned)->get("api/v4/domains/{$domain->id}");
         $response->assertStatus(200);
 
         // Jack has no entitlement/control over kolab.org
         $response = $this->actingAs($jack)->get("api/v4/domains/{$domain->id}");
         $response->assertStatus(403);
     }
 
     /**
      * Test fetching SKUs list for a domain (GET /domains/<id>/skus)
      */
     public function testSkus(): void
     {
         $user = $this->getTestUser('john@kolab.org');
         $domain = $this->getTestDomain('kolab.org');
 
         // Unauth access not allowed
         $response = $this->get("api/v4/domains/{$domain->id}/skus");
         $response->assertStatus(401);
 
         // Create an sku for another tenant, to make sure it is not included in the result
         $nsku = Sku::create([
                 'title' => 'test',
                 'name' => 'Test',
                 'description' => '',
                 'active' => true,
                 'cost' => 100,
                 'handler_class' => 'App\Handlers\Domain',
         ]);
         $tenant = Tenant::whereNotIn('id', [\config('app.tenant_id')])->first();
         $nsku->tenant_id = $tenant->id;
         $nsku->save();
 
         $response = $this->actingAs($user)->get("api/v4/domains/{$domain->id}/skus");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertCount(1, $json);
         $this->assertSkuElement('domain-hosting', $json[0], [
                 'prio' => 0,
                 'type' => 'domain',
                 'handler' => 'DomainHosting',
                 'enabled' => true,
                 'readonly' => true,
         ]);
     }
 
     /**
      * Test fetching domain status (GET /api/v4/domains/<domain-id>/status)
      * and forcing setup process update (?refresh=1)
      *
      * @group dns
      */
     public function testStatus(): void
     {
         $john = $this->getTestUser('john@kolab.org');
         $jack = $this->getTestUser('jack@kolab.org');
         $domain = $this->getTestDomain('kolab.org');
 
         // Test unauthorized access
         $response = $this->actingAs($jack)->get("/api/v4/domains/{$domain->id}/status");
         $response->assertStatus(403);
 
         $domain->status = Domain::STATUS_NEW | Domain::STATUS_ACTIVE | Domain::STATUS_LDAP_READY;
         $domain->save();
 
         // Get domain status
         $response = $this->actingAs($john)->get("/api/v4/domains/{$domain->id}/status");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertFalse($json['isVerified']);
         $this->assertFalse($json['isReady']);
+        $this->assertFalse($json['isDone']);
         $this->assertCount(4, $json['process']);
         $this->assertSame('domain-verified', $json['process'][2]['label']);
         $this->assertSame(false, $json['process'][2]['state']);
         $this->assertTrue(empty($json['status']));
         $this->assertTrue(empty($json['message']));
 
         // Now "reboot" the process and verify the domain
         $response = $this->actingAs($john)->get("/api/v4/domains/{$domain->id}/status?refresh=1");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertTrue($json['isVerified']);
         $this->assertTrue($json['isReady']);
+        $this->assertTrue($json['isDone']);
         $this->assertCount(4, $json['process']);
         $this->assertSame('domain-verified', $json['process'][2]['label']);
         $this->assertSame(true, $json['process'][2]['state']);
         $this->assertSame('domain-confirmed', $json['process'][3]['label']);
         $this->assertSame(true, $json['process'][3]['state']);
         $this->assertSame('success', $json['status']);
         $this->assertSame('Setup process finished successfully.', $json['message']);
 
         // TODO: Test completing all process steps
     }
 
     /**
      * Test domain creation (POST /api/v4/domains)
      */
     public function testStore(): void
     {
         Queue::fake();
 
         $jack = $this->getTestUser('jack@kolab.org');
         $john = $this->getTestUser('john@kolab.org');
 
         // Test empty request
         $response = $this->actingAs($john)->post("/api/v4/domains", []);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertSame("The namespace field is required.", $json['errors']['namespace'][0]);
         $this->assertCount(1, $json['errors']);
         $this->assertCount(1, $json['errors']['namespace']);
         $this->assertCount(2, $json);
 
         // Test access by user not being a wallet controller
         $post = ['namespace' => 'domainscontroller.com'];
         $response = $this->actingAs($jack)->post("/api/v4/domains", $post);
         $json = $response->json();
 
         $response->assertStatus(403);
 
         $this->assertSame('error', $json['status']);
         $this->assertSame("Access denied", $json['message']);
         $this->assertCount(2, $json);
 
         // Test some invalid data
         $post = ['namespace' => '--'];
         $response = $this->actingAs($john)->post("/api/v4/domains", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(2, $json);
         $this->assertSame('The specified domain is invalid.', $json['errors']['namespace'][0]);
         $this->assertCount(1, $json['errors']);
         $this->assertCount(1, $json['errors']['namespace']);
 
         // Test an existing domain
         $post = ['namespace' => 'kolab.org'];
         $response = $this->actingAs($john)->post("/api/v4/domains", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(2, $json);
         $this->assertSame('The specified domain is not available.', $json['errors']['namespace']);
 
         $package_kolab = \App\Package::withEnvTenantContext()->where('title', 'kolab')->first();
         $package_domain = \App\Package::withEnvTenantContext()->where('title', 'domain-hosting')->first();
 
         // Missing package
         $post = ['namespace' => 'domainscontroller.com'];
         $response = $this->actingAs($john)->post("/api/v4/domains", $post);
         $json = $response->json();
 
         $response->assertStatus(422);
 
         $this->assertSame('error', $json['status']);
         $this->assertSame("Package is required.", $json['errors']['package']);
         $this->assertCount(2, $json);
 
         // Invalid package
         $post['package'] = $package_kolab->id;
         $response = $this->actingAs($john)->post("/api/v4/domains", $post);
         $json = $response->json();
 
         $response->assertStatus(422);
 
         $this->assertSame('error', $json['status']);
         $this->assertSame("Invalid package selected.", $json['errors']['package']);
         $this->assertCount(2, $json);
 
         // Test full and valid data
         $post['package'] = $package_domain->id;
         $response = $this->actingAs($john)->post("/api/v4/domains", $post);
         $json = $response->json();
 
         $response->assertStatus(200);
 
         $this->assertSame('success', $json['status']);
         $this->assertSame("Domain created successfully.", $json['message']);
         $this->assertCount(2, $json);
 
         $domain = Domain::where('namespace', $post['namespace'])->first();
         $this->assertInstanceOf(Domain::class, $domain);
 
         // Assert the new domain entitlements
         $this->assertEntitlements($domain, ['domain-hosting']);
 
         // Assert the wallet to which the new domain should be assigned to
         $wallet = $domain->wallet();
         $this->assertSame($john->wallets->first()->id, $wallet->id);
 
         // Test re-creating a domain
         $domain->delete();
 
         $response = $this->actingAs($john)->post("/api/v4/domains", $post);
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame('success', $json['status']);
         $this->assertSame("Domain created successfully.", $json['message']);
         $this->assertCount(2, $json);
 
         $domain = Domain::where('namespace', $post['namespace'])->first();
         $this->assertInstanceOf(Domain::class, $domain);
         $this->assertEntitlements($domain, ['domain-hosting']);
         $wallet = $domain->wallet();
         $this->assertSame($john->wallets->first()->id, $wallet->id);
 
         // Test creating a domain that is soft-deleted and belongs to another user
         $domain->delete();
         $domain->entitlements()->withTrashed()->update(['wallet_id' => $jack->wallets->first()->id]);
 
         $response = $this->actingAs($john)->post("/api/v4/domains", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(2, $json);
         $this->assertSame('The specified domain is not available.', $json['errors']['namespace']);
 
         // Test acting as account controller (not owner)
 
         $this->markTestIncomplete();
     }
 }
diff --git a/src/tests/Feature/Controller/GroupsTest.php b/src/tests/Feature/Controller/GroupsTest.php
index 4b410cc5..68696710 100644
--- a/src/tests/Feature/Controller/GroupsTest.php
+++ b/src/tests/Feature/Controller/GroupsTest.php
@@ -1,650 +1,650 @@
 <?php
 
 namespace Tests\Feature\Controller;
 
 use App\Group;
 use App\Http\Controllers\API\V4\GroupsController;
 use Carbon\Carbon;
 use Illuminate\Support\Facades\Queue;
 use Tests\TestCase;
 
 class GroupsTest extends TestCase
 {
     /**
      * {@inheritDoc}
      */
     public function setUp(): void
     {
         parent::setUp();
 
         $this->deleteTestGroup('group-test@kolab.org');
         $this->deleteTestGroup('group-test2@kolab.org');
     }
 
     /**
      * {@inheritDoc}
      */
     public function tearDown(): void
     {
         $this->deleteTestGroup('group-test@kolab.org');
         $this->deleteTestGroup('group-test2@kolab.org');
 
         parent::tearDown();
     }
 
     /**
      * Test group deleting (DELETE /api/v4/groups/<id>)
      */
     public function testDestroy(): void
     {
         // First create some groups to delete
         $john = $this->getTestUser('john@kolab.org');
         $jack = $this->getTestUser('jack@kolab.org');
         $group = $this->getTestGroup('group-test@kolab.org');
         $group->assignToWallet($john->wallets->first());
 
         // Test unauth access
         $response = $this->delete("api/v4/groups/{$group->id}");
         $response->assertStatus(401);
 
         // Test non-existing group
         $response = $this->actingAs($john)->delete("api/v4/groups/abc");
         $response->assertStatus(404);
 
         // Test access to other user's group
         $response = $this->actingAs($jack)->delete("api/v4/groups/{$group->id}");
         $response->assertStatus(403);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertSame("Access denied", $json['message']);
         $this->assertCount(2, $json);
 
         // Test removing a group
         $response = $this->actingAs($john)->delete("api/v4/groups/{$group->id}");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertEquals('success', $json['status']);
         $this->assertEquals("Distribution list deleted successfully.", $json['message']);
     }
 
     /**
      * Test groups listing (GET /api/v4/groups)
      */
     public function testIndex(): void
     {
         $jack = $this->getTestUser('jack@kolab.org');
         $john = $this->getTestUser('john@kolab.org');
         $ned = $this->getTestUser('ned@kolab.org');
 
         $group = $this->getTestGroup('group-test@kolab.org');
         $group->assignToWallet($john->wallets->first());
 
         // Test unauth access
         $response = $this->get("api/v4/groups");
         $response->assertStatus(401);
 
         // Test a user with no groups
         $response = $this->actingAs($jack)->get("/api/v4/groups");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertCount(4, $json);
         $this->assertSame(0, $json['count']);
         $this->assertSame(false, $json['hasMore']);
         $this->assertSame("0 distribution lists have been found.", $json['message']);
         $this->assertSame([], $json['list']);
 
         // Test a user with a single group
         $response = $this->actingAs($john)->get("/api/v4/groups");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertCount(4, $json);
         $this->assertSame(1, $json['count']);
         $this->assertSame(false, $json['hasMore']);
         $this->assertSame("1 distribution lists have been found.", $json['message']);
         $this->assertCount(1, $json['list']);
         $this->assertSame($group->id, $json['list'][0]['id']);
         $this->assertSame($group->email, $json['list'][0]['email']);
         $this->assertSame($group->name, $json['list'][0]['name']);
         $this->assertArrayHasKey('isDeleted', $json['list'][0]);
         $this->assertArrayHasKey('isSuspended', $json['list'][0]);
         $this->assertArrayHasKey('isActive', $json['list'][0]);
         $this->assertArrayHasKey('isLdapReady', $json['list'][0]);
 
         // Test that another wallet controller has access to groups
         $response = $this->actingAs($ned)->get("/api/v4/groups");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertCount(4, $json);
         $this->assertSame(1, $json['count']);
         $this->assertSame(false, $json['hasMore']);
         $this->assertSame("1 distribution lists have been found.", $json['message']);
         $this->assertCount(1, $json['list']);
         $this->assertSame($group->email, $json['list'][0]['email']);
     }
 
     /**
      * Test group config update (POST /api/v4/groups/<group>/config)
      */
     public function testSetConfig(): void
     {
         $john = $this->getTestUser('john@kolab.org');
         $jack = $this->getTestUser('jack@kolab.org');
         $group = $this->getTestGroup('group-test@kolab.org');
         $group->assignToWallet($john->wallets->first());
 
         // Test unknown group id
         $post = ['sender_policy' => []];
         $response = $this->actingAs($john)->post("/api/v4/groups/123/config", $post);
         $json = $response->json();
 
         $response->assertStatus(404);
 
         // Test access by user not being a wallet controller
         $post = ['sender_policy' => []];
         $response = $this->actingAs($jack)->post("/api/v4/groups/{$group->id}/config", $post);
         $json = $response->json();
 
         $response->assertStatus(403);
 
         $this->assertSame('error', $json['status']);
         $this->assertSame("Access denied", $json['message']);
         $this->assertCount(2, $json);
 
         // Test some invalid data
         $post = ['test' => 1];
         $response = $this->actingAs($john)->post("/api/v4/groups/{$group->id}/config", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(2, $json);
         $this->assertCount(1, $json['errors']);
         $this->assertSame('The requested configuration parameter is not supported.', $json['errors']['test']);
 
         $group->refresh();
 
         $this->assertNull($group->getSetting('test'));
         $this->assertNull($group->getSetting('sender_policy'));
 
         // Test some valid data
         $post = ['sender_policy' => ['domain.com']];
         $response = $this->actingAs($john)->post("/api/v4/groups/{$group->id}/config", $post);
 
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertCount(2, $json);
         $this->assertSame('success', $json['status']);
         $this->assertSame('Distribution list settings updated successfully.', $json['message']);
 
         $this->assertSame(['sender_policy' => $post['sender_policy']], $group->fresh()->getConfig());
 
         // Test input validation
         $post = ['sender_policy' => [5]];
         $response = $this->actingAs($john)->post("/api/v4/groups/{$group->id}/config", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertCount(2, $json);
         $this->assertSame('error', $json['status']);
         $this->assertCount(1, $json['errors']);
         $this->assertSame(
             'The entry format is invalid. Expected an email, domain, or part of it.',
             $json['errors']['sender_policy'][0]
         );
 
         $this->assertSame(['sender_policy' => ['domain.com']], $group->fresh()->getConfig());
     }
 
     /**
      * Test fetching group data/profile (GET /api/v4/groups/<group-id>)
      */
     public function testShow(): void
     {
         $jack = $this->getTestUser('jack@kolab.org');
         $john = $this->getTestUser('john@kolab.org');
         $ned = $this->getTestUser('ned@kolab.org');
 
         $group = $this->getTestGroup('group-test@kolab.org');
         $group->assignToWallet($john->wallets->first());
         $group->setSetting('sender_policy', '["test"]');
 
         // Test unauthorized access to a profile of other user
         $response = $this->get("/api/v4/groups/{$group->id}");
         $response->assertStatus(401);
 
         // Test unauthorized access to a group of another user
         $response = $this->actingAs($jack)->get("/api/v4/groups/{$group->id}");
         $response->assertStatus(403);
 
         // John: Group owner - non-existing group
         $response = $this->actingAs($john)->get("/api/v4/groups/abc");
         $response->assertStatus(404);
 
         // John: Group owner
         $response = $this->actingAs($john)->get("/api/v4/groups/{$group->id}");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame($group->id, $json['id']);
         $this->assertSame($group->email, $json['email']);
         $this->assertSame($group->name, $json['name']);
         $this->assertSame($group->members, $json['members']);
         $this->assertTrue(!empty($json['statusInfo']));
         $this->assertArrayHasKey('isDeleted', $json);
         $this->assertArrayHasKey('isSuspended', $json);
         $this->assertArrayHasKey('isActive', $json);
         $this->assertArrayHasKey('isLdapReady', $json);
         $this->assertSame(['sender_policy' => ['test']], $json['config']);
         $this->assertCount(1, $json['skus']);
     }
 
     /**
      * Test fetching SKUs list for a group (GET /groups/<id>/skus)
      */
     public function testSkus(): void
     {
         Queue::fake();
 
         $john = $this->getTestUser('john@kolab.org');
         $jack = $this->getTestUser('jack@kolab.org');
 
         $group = $this->getTestGroup('group-test@kolab.org');
         $group->assignToWallet($john->wallets->first());
 
         // Unauth access not allowed
         $response = $this->get("api/v4/groups/{$group->id}/skus");
         $response->assertStatus(401);
 
         // Unauthorized access not allowed
         $response = $this->actingAs($jack)->get("api/v4/groups/{$group->id}/skus");
         $response->assertStatus(403);
 
         $response = $this->actingAs($john)->get("api/v4/groups/{$group->id}/skus");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertCount(1, $json);
         $this->assertSkuElement('group', $json[0], [
                 'prio' => 0,
                 'type' => 'group',
                 'handler' => 'Group',
                 'enabled' => true,
                 'readonly' => true,
         ]);
     }
 
     /**
      * Test fetching group status (GET /api/v4/groups/<group-id>/status)
      * and forcing setup process update (?refresh=1)
      */
     public function testStatus(): void
     {
         Queue::fake();
 
         $john = $this->getTestUser('john@kolab.org');
         $jack = $this->getTestUser('jack@kolab.org');
 
         $group = $this->getTestGroup('group-test@kolab.org');
         $group->assignToWallet($john->wallets->first());
 
         // Test unauthorized access
         $response = $this->get("/api/v4/groups/abc/status");
         $response->assertStatus(401);
 
         // Test unauthorized access
         $response = $this->actingAs($jack)->get("/api/v4/groups/{$group->id}/status");
         $response->assertStatus(403);
 
         $group->status = Group::STATUS_NEW | Group::STATUS_ACTIVE;
         $group->save();
 
         // Get group status
         $response = $this->actingAs($john)->get("/api/v4/groups/{$group->id}/status");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertFalse($json['isLdapReady']);
         $this->assertFalse($json['isReady']);
         $this->assertFalse($json['isSuspended']);
         $this->assertTrue($json['isActive']);
         $this->assertFalse($json['isDeleted']);
         $this->assertCount(6, $json['process']);
         $this->assertSame('distlist-new', $json['process'][0]['label']);
         $this->assertSame(true, $json['process'][0]['state']);
         $this->assertSame('distlist-ldap-ready', $json['process'][1]['label']);
         $this->assertSame(false, $json['process'][1]['state']);
         $this->assertTrue(empty($json['status']));
         $this->assertTrue(empty($json['message']));
 
         // Make sure the domain is confirmed (other test might unset that status)
         $domain = $this->getTestDomain('kolab.org');
         $domain->status |= \App\Domain::STATUS_CONFIRMED;
         $domain->save();
 
         // Now "reboot" the process and  the group
         $response = $this->actingAs($john)->get("/api/v4/groups/{$group->id}/status?refresh=1");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertTrue($json['isLdapReady']);
         $this->assertTrue($json['isReady']);
         $this->assertCount(6, $json['process']);
         $this->assertSame('distlist-ldap-ready', $json['process'][1]['label']);
         $this->assertSame(true, $json['process'][1]['state']);
         $this->assertSame('success', $json['status']);
         $this->assertSame('Setup process finished successfully.', $json['message']);
 
         // Test a case when a domain is not ready
         $domain->status ^= \App\Domain::STATUS_CONFIRMED;
         $domain->save();
 
         $response = $this->actingAs($john)->get("/api/v4/groups/{$group->id}/status?refresh=1");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertTrue($json['isLdapReady']);
         $this->assertTrue($json['isReady']);
         $this->assertCount(6, $json['process']);
         $this->assertSame('distlist-ldap-ready', $json['process'][1]['label']);
         $this->assertSame(true, $json['process'][1]['state']);
         $this->assertSame('success', $json['status']);
         $this->assertSame('Setup process finished successfully.', $json['message']);
     }
 
     /**
      * Test GroupsController::statusInfo()
      */
     public function testStatusInfo(): void
     {
         $john = $this->getTestUser('john@kolab.org');
         $group = $this->getTestGroup('group-test@kolab.org');
         $group->assignToWallet($john->wallets->first());
         $group->status = Group::STATUS_NEW | Group::STATUS_ACTIVE;
         $group->save();
 
         $result = GroupsController::statusInfo($group);
 
-        $this->assertFalse($result['isReady']);
+        $this->assertFalse($result['isDone']);
         $this->assertCount(6, $result['process']);
         $this->assertSame('distlist-new', $result['process'][0]['label']);
         $this->assertSame(true, $result['process'][0]['state']);
         $this->assertSame('distlist-ldap-ready', $result['process'][1]['label']);
         $this->assertSame(false, $result['process'][1]['state']);
         $this->assertSame('running', $result['processState']);
 
         $group->created_at = Carbon::now()->subSeconds(181);
         $group->save();
 
         $result = GroupsController::statusInfo($group);
 
         $this->assertSame('failed', $result['processState']);
 
         $group->status |= Group::STATUS_LDAP_READY;
         $group->save();
 
         $result = GroupsController::statusInfo($group);
 
-        $this->assertTrue($result['isReady']);
+        $this->assertTrue($result['isDone']);
         $this->assertCount(6, $result['process']);
         $this->assertSame('distlist-new', $result['process'][0]['label']);
         $this->assertSame(true, $result['process'][0]['state']);
         $this->assertSame('distlist-ldap-ready', $result['process'][1]['label']);
         $this->assertSame(true, $result['process'][2]['state']);
         $this->assertSame('done', $result['processState']);
     }
 
     /**
      * Test group creation (POST /api/v4/groups)
      */
     public function testStore(): void
     {
         Queue::fake();
 
         $jack = $this->getTestUser('jack@kolab.org');
         $john = $this->getTestUser('john@kolab.org');
 
         // Test unauth request
         $response = $this->post("/api/v4/groups", []);
         $response->assertStatus(401);
 
         // Test non-controller user
         $response = $this->actingAs($jack)->post("/api/v4/groups", []);
         $response->assertStatus(403);
 
         // Test empty request
         $response = $this->actingAs($john)->post("/api/v4/groups", []);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertSame("The email field is required.", $json['errors']['email']);
         $this->assertSame("At least one recipient is required.", $json['errors']['members']);
         $this->assertSame("The name field is required.", $json['errors']['name'][0]);
         $this->assertCount(2, $json);
         $this->assertCount(3, $json['errors']);
 
         // Test missing members and name
         $post = ['email' => 'group-test@kolab.org'];
         $response = $this->actingAs($john)->post("/api/v4/groups", $post);
         $json = $response->json();
 
         $response->assertStatus(422);
 
         $this->assertSame('error', $json['status']);
         $this->assertSame("At least one recipient is required.", $json['errors']['members']);
         $this->assertSame("The name field is required.", $json['errors']['name'][0]);
         $this->assertCount(2, $json);
         $this->assertCount(2, $json['errors']);
 
         // Test invalid email and too long name
         $post = ['email' => 'invalid', 'name' => str_repeat('A', 192)];
         $response = $this->actingAs($john)->post("/api/v4/groups", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(2, $json);
         $this->assertSame("The specified email is invalid.", $json['errors']['email']);
         $this->assertSame("The name may not be greater than 191 characters.", $json['errors']['name'][0]);
         $this->assertCount(3, $json['errors']);
 
         // Test successful group creation
         $post = [
             'name' => 'Test Group',
             'email' => 'group-test@kolab.org',
             'members' => ['test1@domain.tld', 'test2@domain.tld']
         ];
 
         $response = $this->actingAs($john)->post("/api/v4/groups", $post);
         $json = $response->json();
 
         $response->assertStatus(200);
 
         $this->assertSame('success', $json['status']);
         $this->assertSame("Distribution list created successfully.", $json['message']);
         $this->assertCount(2, $json);
 
         $group = Group::where('email', 'group-test@kolab.org')->first();
         $this->assertInstanceOf(Group::class, $group);
         $this->assertSame($post['email'], $group->email);
         $this->assertSame($post['members'], $group->members);
         $this->assertTrue($john->groups()->get()->contains($group));
 
         // Group name must be unique within a domain
         $post['email'] = 'group-test2@kolab.org';
         $post['members'] = ['test1@domain.tld'];
 
         $response = $this->actingAs($john)->post("/api/v4/groups", $post);
         $response->assertStatus(422);
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(2, $json);
         $this->assertCount(1, $json['errors']);
         $this->assertSame("The specified name is not available.", $json['errors']['name'][0]);
     }
 
     /**
      * Test group update (PUT /api/v4/groups/<group-id>)
      */
     public function testUpdate(): void
     {
         Queue::fake();
 
         $jack = $this->getTestUser('jack@kolab.org');
         $john = $this->getTestUser('john@kolab.org');
         $ned = $this->getTestUser('ned@kolab.org');
 
         $group = $this->getTestGroup('group-test@kolab.org');
         $group->assignToWallet($john->wallets->first());
 
         // Test unauthorized update
         $response = $this->get("/api/v4/groups/{$group->id}", []);
         $response->assertStatus(401);
 
         // Test unauthorized update
         $response = $this->actingAs($jack)->get("/api/v4/groups/{$group->id}", []);
         $response->assertStatus(403);
 
         // Test updating - missing members
         $response = $this->actingAs($john)->put("/api/v4/groups/{$group->id}", []);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertSame("At least one recipient is required.", $json['errors']['members']);
         $this->assertCount(2, $json);
 
         // Test some invalid data
         $post = ['members' => ['test@domain.tld', 'invalid']];
         $response = $this->actingAs($john)->put("/api/v4/groups/{$group->id}", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(2, $json);
         $this->assertSame('The specified email address is invalid.', $json['errors']['members'][1]);
 
         // Valid data - members and name changed
         $post = [
             'name' => 'Test Gr',
             'members' => ['member1@test.domain', 'member2@test.domain']
         ];
 
         $response = $this->actingAs($john)->put("/api/v4/groups/{$group->id}", $post);
         $json = $response->json();
 
         $response->assertStatus(200);
 
         $this->assertSame('success', $json['status']);
         $this->assertSame("Distribution list updated successfully.", $json['message']);
         $this->assertCount(2, $json);
 
         $group->refresh();
 
         $this->assertSame($post['name'], $group->name);
         $this->assertSame($post['members'], $group->members);
     }
 
     /**
      * Group email address validation.
      */
     public function testValidateGroupEmail(): void
     {
         $john = $this->getTestUser('john@kolab.org');
         $group = $this->getTestGroup('group-test@kolab.org');
 
         // Invalid email
         $result = GroupsController::validateGroupEmail('', $john);
         $this->assertSame("The email field is required.", $result);
 
         $result = GroupsController::validateGroupEmail('kolab.org', $john);
         $this->assertSame("The specified email is invalid.", $result);
 
         $result = GroupsController::validateGroupEmail('.@kolab.org', $john);
         $this->assertSame("The specified email is invalid.", $result);
 
         $result = GroupsController::validateGroupEmail('test123456@localhost', $john);
         $this->assertSame("The specified domain is invalid.", $result);
 
         $result = GroupsController::validateGroupEmail('test123456@unknown-domain.org', $john);
         $this->assertSame("The specified domain is invalid.", $result);
 
         // forbidden public domain
         $result = GroupsController::validateGroupEmail('testtest@kolabnow.com', $john);
         $this->assertSame("The specified domain is not available.", $result);
 
         // existing alias
         $result = GroupsController::validateGroupEmail('jack.daniels@kolab.org', $john);
         $this->assertSame("The specified email is not available.", $result);
 
         // existing user
         $result = GroupsController::validateGroupEmail('ned@kolab.org', $john);
         $this->assertSame("The specified email is not available.", $result);
 
         // existing group
         $result = GroupsController::validateGroupEmail('group-test@kolab.org', $john);
         $this->assertSame("The specified email is not available.", $result);
 
         // valid
         $result = GroupsController::validateGroupEmail('admin@kolab.org', $john);
         $this->assertSame(null, $result);
     }
 
     /**
      * Group member email address validation.
      */
     public function testValidateMemberEmail(): void
     {
         $john = $this->getTestUser('john@kolab.org');
 
         // Invalid format
         $result = GroupsController::validateMemberEmail('kolab.org', $john);
         $this->assertSame("The specified email address is invalid.", $result);
 
         $result = GroupsController::validateMemberEmail('.@kolab.org', $john);
         $this->assertSame("The specified email address is invalid.", $result);
 
         $result = GroupsController::validateMemberEmail('test123456@localhost', $john);
         $this->assertSame("The specified email address is invalid.", $result);
 
         // Test local non-existing user
         $result = GroupsController::validateMemberEmail('unknown@kolab.org', $john);
         $this->assertSame("The specified email address does not exist.", $result);
 
         // Test local existing user
         $result = GroupsController::validateMemberEmail('ned@kolab.org', $john);
         $this->assertSame(null, $result);
 
         // Test existing user, but not in the same account
         $result = GroupsController::validateMemberEmail('jeroen@jeroen.jeroen', $john);
         $this->assertSame(null, $result);
 
         // Valid address
         $result = GroupsController::validateMemberEmail('test@google.com', $john);
         $this->assertSame(null, $result);
     }
 }
diff --git a/src/tests/Feature/Controller/ResourcesTest.php b/src/tests/Feature/Controller/ResourcesTest.php
index 0d89ea57..04268ec8 100644
--- a/src/tests/Feature/Controller/ResourcesTest.php
+++ b/src/tests/Feature/Controller/ResourcesTest.php
@@ -1,564 +1,563 @@
 <?php
 
 namespace Tests\Feature\Controller;
 
 use App\Resource;
 use App\Http\Controllers\API\V4\ResourcesController;
 use Carbon\Carbon;
 use Illuminate\Support\Facades\Queue;
 use Tests\TestCase;
 
 class ResourcesTest extends TestCase
 {
     /**
      * {@inheritDoc}
      */
     public function setUp(): void
     {
         parent::setUp();
 
         $this->deleteTestResource('resource-test@kolab.org');
         Resource::where('name', 'Test Resource')->delete();
     }
 
     /**
      * {@inheritDoc}
      */
     public function tearDown(): void
     {
         $this->deleteTestResource('resource-test@kolab.org');
         Resource::where('name', 'Test Resource')->delete();
 
         parent::tearDown();
     }
 
     /**
      * Test resource deleting (DELETE /api/v4/resources/<id>)
      */
     public function testDestroy(): void
     {
         // First create some groups to delete
         $john = $this->getTestUser('john@kolab.org');
         $jack = $this->getTestUser('jack@kolab.org');
         $resource = $this->getTestResource('resource-test@kolab.org');
         $resource->assignToWallet($john->wallets->first());
 
         // Test unauth access
         $response = $this->delete("api/v4/resources/{$resource->id}");
         $response->assertStatus(401);
 
         // Test non-existing resource
         $response = $this->actingAs($john)->delete("api/v4/resources/abc");
         $response->assertStatus(404);
 
         // Test access to other user's resource
         $response = $this->actingAs($jack)->delete("api/v4/resources/{$resource->id}");
         $response->assertStatus(403);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertSame("Access denied", $json['message']);
         $this->assertCount(2, $json);
 
         // Test removing a resource
         $response = $this->actingAs($john)->delete("api/v4/resources/{$resource->id}");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertEquals('success', $json['status']);
         $this->assertEquals("Resource deleted successfully.", $json['message']);
     }
 
     /**
      * Test resources listing (GET /api/v4/resources)
      */
     public function testIndex(): void
     {
         $jack = $this->getTestUser('jack@kolab.org');
         $john = $this->getTestUser('john@kolab.org');
         $ned = $this->getTestUser('ned@kolab.org');
 
         // Test unauth access
         $response = $this->get("api/v4/resources");
         $response->assertStatus(401);
 
         // Test a user with no resources
         $response = $this->actingAs($jack)->get("/api/v4/resources");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertCount(4, $json);
         $this->assertSame(0, $json['count']);
         $this->assertSame(false, $json['hasMore']);
         $this->assertSame("0 resources have been found.", $json['message']);
         $this->assertSame([], $json['list']);
 
         // Test a user with two resources
         $response = $this->actingAs($john)->get("/api/v4/resources");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $resource = Resource::where('name', 'Conference Room #1')->first();
 
         $this->assertCount(4, $json);
         $this->assertSame(2, $json['count']);
         $this->assertSame(false, $json['hasMore']);
         $this->assertSame("2 resources have been found.", $json['message']);
         $this->assertCount(2, $json['list']);
         $this->assertSame($resource->id, $json['list'][0]['id']);
         $this->assertSame($resource->email, $json['list'][0]['email']);
         $this->assertSame($resource->name, $json['list'][0]['name']);
         $this->assertArrayHasKey('isDeleted', $json['list'][0]);
         $this->assertArrayHasKey('isActive', $json['list'][0]);
-        $this->assertArrayHasKey('isLdapReady', $json['list'][0]);
-        if (\config('app.with_imap')) {
-            $this->assertArrayHasKey('isImapReady', $json['list'][0]);
+        $this->assertArrayHasKey('isImapReady', $json['list'][0]);
+        if (\config('app.with_ldap')) {
+            $this->assertArrayHasKey('isLdapReady', $json['list'][0]);
         }
 
         // Test that another wallet controller has access to resources
         $response = $this->actingAs($ned)->get("/api/v4/resources");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertCount(4, $json);
         $this->assertSame(2, $json['count']);
         $this->assertSame(false, $json['hasMore']);
         $this->assertSame("2 resources have been found.", $json['message']);
         $this->assertCount(2, $json['list']);
         $this->assertSame($resource->email, $json['list'][0]['email']);
     }
 
     /**
      * Test resource config update (POST /api/v4/resources/<resource>/config)
      */
     public function testSetConfig(): void
     {
         $john = $this->getTestUser('john@kolab.org');
         $jack = $this->getTestUser('jack@kolab.org');
         $resource = $this->getTestResource('resource-test@kolab.org');
         $resource->assignToWallet($john->wallets->first());
 
         // Test unknown resource id
         $post = ['invitation_policy' => 'reject'];
         $response = $this->actingAs($john)->post("/api/v4/resources/123/config", $post);
         $json = $response->json();
 
         $response->assertStatus(404);
 
         // Test access by user not being a wallet controller
         $post = ['invitation_policy' => 'reject'];
         $response = $this->actingAs($jack)->post("/api/v4/resources/{$resource->id}/config", $post);
         $json = $response->json();
 
         $response->assertStatus(403);
 
         $this->assertSame('error', $json['status']);
         $this->assertSame("Access denied", $json['message']);
         $this->assertCount(2, $json);
 
         // Test some invalid data
         $post = ['test' => 1];
         $response = $this->actingAs($john)->post("/api/v4/resources/{$resource->id}/config", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(2, $json);
         $this->assertCount(1, $json['errors']);
         $this->assertSame('The requested configuration parameter is not supported.', $json['errors']['test']);
 
         $resource->refresh();
 
         $this->assertNull($resource->getSetting('test'));
         $this->assertNull($resource->getSetting('invitation_policy'));
 
         // Test some valid data
         $post = ['invitation_policy' => 'reject'];
         $response = $this->actingAs($john)->post("/api/v4/resources/{$resource->id}/config", $post);
 
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertCount(2, $json);
         $this->assertSame('success', $json['status']);
         $this->assertSame("Resource settings updated successfully.", $json['message']);
 
         $this->assertSame(['invitation_policy' => 'reject'], $resource->fresh()->getConfig());
 
         // Test input validation
         $post = ['invitation_policy' => 'aaa'];
         $response = $this->actingAs($john)->post("/api/v4/resources/{$resource->id}/config", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertCount(2, $json);
         $this->assertSame('error', $json['status']);
         $this->assertCount(1, $json['errors']);
         $this->assertSame(
             "The specified invitation policy is invalid.",
             $json['errors']['invitation_policy']
         );
 
         $this->assertSame(['invitation_policy' => 'reject'], $resource->fresh()->getConfig());
     }
 
     /**
      * Test fetching resource data/profile (GET /api/v4/resources/<resource>)
      */
     public function testShow(): void
     {
         $jack = $this->getTestUser('jack@kolab.org');
         $john = $this->getTestUser('john@kolab.org');
         $ned = $this->getTestUser('ned@kolab.org');
 
         $resource = $this->getTestResource('resource-test@kolab.org');
         $resource->assignToWallet($john->wallets->first());
         $resource->setSetting('invitation_policy', 'reject');
 
         // Test unauthorized access to a profile of other user
         $response = $this->get("/api/v4/resources/{$resource->id}");
         $response->assertStatus(401);
 
         // Test unauthorized access to a resource of another user
         $response = $this->actingAs($jack)->get("/api/v4/resources/{$resource->id}");
         $response->assertStatus(403);
 
         // John: Account owner - non-existing resource
         $response = $this->actingAs($john)->get("/api/v4/resources/abc");
         $response->assertStatus(404);
 
         // John: Account owner
         $response = $this->actingAs($john)->get("/api/v4/resources/{$resource->id}");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame($resource->id, $json['id']);
         $this->assertSame($resource->email, $json['email']);
         $this->assertSame($resource->name, $json['name']);
         $this->assertTrue(!empty($json['statusInfo']));
         $this->assertArrayHasKey('isDeleted', $json);
         $this->assertArrayHasKey('isActive', $json);
-        $this->assertArrayHasKey('isLdapReady', $json);
-        if (\config('app.with_imap')) {
-            $this->assertArrayHasKey('isImapReady', $json);
+        $this->assertArrayHasKey('isImapReady', $json);
+        if (\config('app.with_ldap')) {
+            $this->assertArrayHasKey('isLdapReady', $json);
         }
         $this->assertSame(['invitation_policy' => 'reject'], $json['config']);
         $this->assertCount(1, $json['skus']);
     }
 
     /**
      * Test fetching SKUs list for a resource (GET /resources/<id>/skus)
      */
     public function testSkus(): void
     {
         Queue::fake();
 
         $john = $this->getTestUser('john@kolab.org');
         $jack = $this->getTestUser('jack@kolab.org');
 
         $resource = $this->getTestResource('resource-test@kolab.org');
         $resource->assignToWallet($john->wallets->first());
 
         // Unauth access not allowed
         $response = $this->get("api/v4/resources/{$resource->id}/skus");
         $response->assertStatus(401);
 
         // Unauthorized access not allowed
         $response = $this->actingAs($jack)->get("api/v4/resources/{$resource->id}/skus");
         $response->assertStatus(403);
 
         $response = $this->actingAs($john)->get("api/v4/resources/{$resource->id}/skus");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertCount(1, $json);
         $this->assertSkuElement('resource', $json[0], [
                 'prio' => 0,
                 'type' => 'resource',
                 'handler' => 'Resource',
                 'enabled' => true,
                 'readonly' => true,
         ]);
     }
 
     /**
      * Test fetching a resource status (GET /api/v4/resources/<resource>/status)
      * and forcing setup process update (?refresh=1)
      */
     public function testStatus(): void
     {
         Queue::fake();
 
         $john = $this->getTestUser('john@kolab.org');
         $jack = $this->getTestUser('jack@kolab.org');
 
         $resource = $this->getTestResource('resource-test@kolab.org');
         $resource->assignToWallet($john->wallets->first());
 
         // Test unauthorized access
         $response = $this->get("/api/v4/resources/abc/status");
         $response->assertStatus(401);
 
         // Test unauthorized access
         $response = $this->actingAs($jack)->get("/api/v4/resources/{$resource->id}/status");
         $response->assertStatus(403);
 
         $resource->status = Resource::STATUS_NEW | Resource::STATUS_ACTIVE;
         $resource->save();
 
         // Get resource status
         $response = $this->actingAs($john)->get("/api/v4/resources/{$resource->id}/status");
         $response->assertStatus(200);
 
         $json = $response->json();
 
-        $this->assertFalse($json['isLdapReady']);
         $this->assertFalse($json['isReady']);
         $this->assertFalse($json['isDeleted']);
         $this->assertTrue($json['isActive']);
-        if (\config('app.with_imap')) {
-            $this->assertFalse($json['isImapReady']);
-            $this->assertCount(7, $json['process']);
-        } else {
-            $this->assertCount(6, $json['process']);
-        }
+        $this->assertFalse($json['isImapReady']);
         $this->assertSame('resource-new', $json['process'][0]['label']);
         $this->assertSame(true, $json['process'][0]['state']);
-        $this->assertSame('resource-ldap-ready', $json['process'][1]['label']);
-        $this->assertSame(false, $json['process'][1]['state']);
+        if (\config('app.with_ldap')) {
+            $this->assertFalse($json['isLdapReady']);
+            $this->assertSame('resource-ldap-ready', $json['process'][1]['label']);
+            $this->assertSame(false, $json['process'][1]['state']);
+            $this->assertSame('resource-imap-ready', $json['process'][2]['label']);
+            $this->assertSame(false, $json['process'][2]['state']);
+        } else {
+            $this->assertSame('resource-imap-ready', $json['process'][1]['label']);
+            $this->assertSame(false, $json['process'][1]['state']);
+        }
         $this->assertTrue(empty($json['status']));
         $this->assertTrue(empty($json['message']));
         $this->assertSame('running', $json['processState']);
 
         // Make sure the domain is confirmed (other test might unset that status)
         $domain = $this->getTestDomain('kolab.org');
         $domain->status |= \App\Domain::STATUS_CONFIRMED;
         $domain->save();
         $resource->status |= Resource::STATUS_IMAP_READY;
         $resource->save();
 
         // Now "reboot" the process
         Queue::fake();
         $response = $this->actingAs($john)->get("/api/v4/resources/{$resource->id}/status?refresh=1");
         $response->assertStatus(200);
 
         $json = $response->json();
 
-        $this->assertFalse($json['isLdapReady']);
         $this->assertFalse($json['isReady']);
-        if (\config('app.with_imap')) {
-            $this->assertTrue($json['isImapReady']);
-            $this->assertCount(7, $json['process']);
-        } else {
-            $this->assertCount(6, $json['process']);
-        }
-        $this->assertSame('resource-ldap-ready', $json['process'][1]['label']);
-        $this->assertSame(false, $json['process'][1]['state']);
-        if (\config('app.with_imap')) {
+        $this->assertTrue($json['isImapReady']);
+        if (\config('app.with_ldap')) {
+            $this->assertFalse($json['isLdapReady']);
+            $this->assertSame('resource-ldap-ready', $json['process'][1]['label']);
+            $this->assertSame(false, $json['process'][1]['state']);
             $this->assertSame('resource-imap-ready', $json['process'][2]['label']);
+            $this->assertSame(true, $json['process'][2]['state']);
+        } else {
+            $this->assertSame('resource-imap-ready', $json['process'][1]['label']);
+            $this->assertSame(true, $json['process'][1]['state']);
         }
-        $this->assertSame(true, $json['process'][2]['state']);
         $this->assertSame('success', $json['status']);
         $this->assertSame('Setup process has been pushed. Please wait.', $json['message']);
         $this->assertSame('waiting', $json['processState']);
 
         Queue::assertPushed(\App\Jobs\Resource\CreateJob::class, 1);
 
         // Test a case when a domain is not ready
         Queue::fake();
         $domain->status ^= \App\Domain::STATUS_CONFIRMED;
         $domain->save();
 
         $response = $this->actingAs($john)->get("/api/v4/resources/{$resource->id}/status?refresh=1");
         $response->assertStatus(200);
 
         $json = $response->json();
 
-        $this->assertFalse($json['isLdapReady']);
         $this->assertFalse($json['isReady']);
-        if (\config('app.with_imap')) {
-            $this->assertCount(7, $json['process']);
-        } else {
-            $this->assertCount(6, $json['process']);
+        if (\config('app.with_ldap')) {
+            $this->assertFalse($json['isLdapReady']);
+            $this->assertSame('resource-ldap-ready', $json['process'][1]['label']);
+            $this->assertSame(false, $json['process'][1]['state']);
         }
-        $this->assertSame('resource-ldap-ready', $json['process'][1]['label']);
-        $this->assertSame(false, $json['process'][1]['state']);
         $this->assertSame('success', $json['status']);
         $this->assertSame('Setup process has been pushed. Please wait.', $json['message']);
         $this->assertSame('waiting', $json['processState']);
 
         Queue::assertPushed(\App\Jobs\Resource\CreateJob::class, 1);
     }
 
     /**
      * Test ResourcesController::statusInfo()
      */
     public function testStatusInfo(): void
     {
         $john = $this->getTestUser('john@kolab.org');
         $resource = $this->getTestResource('resource-test@kolab.org');
         $resource->assignToWallet($john->wallets->first());
         $resource->status = Resource::STATUS_NEW | Resource::STATUS_ACTIVE;
         $resource->save();
         $domain = $this->getTestDomain('kolab.org');
         $domain->status |= \App\Domain::STATUS_CONFIRMED;
         $domain->save();
 
         $result = ResourcesController::statusInfo($resource);
 
-        $this->assertFalse($result['isReady']);
-        if (\config('app.with_imap')) {
-            $this->assertCount(7, $result['process']);
-        } else {
-            $this->assertCount(6, $result['process']);
-        }
+        $this->assertFalse($result['isDone']);
         $this->assertSame('resource-new', $result['process'][0]['label']);
         $this->assertSame(true, $result['process'][0]['state']);
-        $this->assertSame('resource-ldap-ready', $result['process'][1]['label']);
-        $this->assertSame(false, $result['process'][1]['state']);
+        if (\config('app.with_ldap')) {
+            $this->assertSame('resource-ldap-ready', $result['process'][1]['label']);
+            $this->assertSame(false, $result['process'][1]['state']);
+            $this->assertSame('resource-imap-ready', $result['process'][2]['label']);
+            $this->assertSame(false, $result['process'][2]['state']);
+        } else {
+            $this->assertSame('resource-imap-ready', $result['process'][1]['label']);
+            $this->assertSame(false, $result['process'][1]['state']);
+        }
         $this->assertSame('running', $result['processState']);
 
         $resource->created_at = Carbon::now()->subSeconds(181);
         $resource->save();
 
         $result = ResourcesController::statusInfo($resource);
 
         $this->assertSame('failed', $result['processState']);
 
         $resource->status |= Resource::STATUS_LDAP_READY | Resource::STATUS_IMAP_READY;
         $resource->save();
 
         $result = ResourcesController::statusInfo($resource);
 
-        $this->assertTrue($result['isReady']);
-        if (\config('app.with_imap')) {
-            $this->assertCount(7, $result['process']);
-        } else {
-            $this->assertCount(6, $result['process']);
-        }
+        $this->assertTrue($result['isDone']);
         $this->assertSame('resource-new', $result['process'][0]['label']);
         $this->assertSame(true, $result['process'][0]['state']);
-        $this->assertSame('resource-ldap-ready', $result['process'][1]['label']);
-        $this->assertSame(true, $result['process'][1]['state']);
-        $this->assertSame('resource-ldap-ready', $result['process'][1]['label']);
-        $this->assertSame(true, $result['process'][1]['state']);
+        if (\config('app.with_ldap')) {
+            $this->assertSame('resource-ldap-ready', $result['process'][1]['label']);
+            $this->assertSame(true, $result['process'][1]['state']);
+            $this->assertSame('resource-imap-ready', $result['process'][2]['label']);
+            $this->assertSame(true, $result['process'][2]['state']);
+        } else {
+            $this->assertSame('resource-imap-ready', $result['process'][1]['label']);
+            $this->assertSame(true, $result['process'][1]['state']);
+        }
         $this->assertSame('done', $result['processState']);
     }
 
     /**
      * Test resource creation (POST /api/v4/resources)
      */
     public function testStore(): void
     {
         Queue::fake();
 
         $jack = $this->getTestUser('jack@kolab.org');
         $john = $this->getTestUser('john@kolab.org');
 
         // Test unauth request
         $response = $this->post("/api/v4/resources", []);
         $response->assertStatus(401);
 
         // Test non-controller user
         $response = $this->actingAs($jack)->post("/api/v4/resources", []);
         $response->assertStatus(403);
 
         // Test empty request
         $response = $this->actingAs($john)->post("/api/v4/resources", []);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertSame("The name field is required.", $json['errors']['name'][0]);
         $this->assertCount(2, $json);
         $this->assertCount(1, $json['errors']);
 
         // Test too long name
         $post = ['domain' => 'kolab.org', 'name' => str_repeat('A', 192)];
         $response = $this->actingAs($john)->post("/api/v4/resources", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(2, $json);
         $this->assertSame("The name may not be greater than 191 characters.", $json['errors']['name'][0]);
         $this->assertCount(1, $json['errors']);
 
         // Test successful resource creation
         $post['name'] = 'Test Resource';
         $response = $this->actingAs($john)->post("/api/v4/resources", $post);
         $json = $response->json();
 
         $response->assertStatus(200);
 
         $this->assertSame('success', $json['status']);
         $this->assertSame("Resource created successfully.", $json['message']);
         $this->assertCount(2, $json);
 
         $resource = Resource::where('name', $post['name'])->first();
         $this->assertInstanceOf(Resource::class, $resource);
         $this->assertTrue($john->resources()->get()->contains($resource));
 
         // Resource name must be unique within a domain
         $response = $this->actingAs($john)->post("/api/v4/resources", $post);
         $response->assertStatus(422);
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(2, $json);
         $this->assertCount(1, $json['errors']);
         $this->assertSame("The specified name is not available.", $json['errors']['name'][0]);
     }
 
     /**
      * Test resource update (PUT /api/v4/resources/<resource>)
      */
     public function testUpdate(): void
     {
         Queue::fake();
 
         $jack = $this->getTestUser('jack@kolab.org');
         $john = $this->getTestUser('john@kolab.org');
         $ned = $this->getTestUser('ned@kolab.org');
 
         $resource = $this->getTestResource('resource-test@kolab.org');
         $resource->assignToWallet($john->wallets->first());
 
         // Test unauthorized update
         $response = $this->get("/api/v4/resources/{$resource->id}", []);
         $response->assertStatus(401);
 
         // Test unauthorized update
         $response = $this->actingAs($jack)->get("/api/v4/resources/{$resource->id}", []);
         $response->assertStatus(403);
 
         // Name change
         $post = [
             'name' => 'Test Res',
         ];
 
         $response = $this->actingAs($john)->put("/api/v4/resources/{$resource->id}", $post);
         $json = $response->json();
 
         $response->assertStatus(200);
 
         $this->assertSame('success', $json['status']);
         $this->assertSame("Resource updated successfully.", $json['message']);
         $this->assertCount(2, $json);
 
         $resource->refresh();
         $this->assertSame($post['name'], $resource->name);
     }
 }
diff --git a/src/tests/Feature/Controller/SharedFoldersTest.php b/src/tests/Feature/Controller/SharedFoldersTest.php
index 70388614..75ebdb60 100644
--- a/src/tests/Feature/Controller/SharedFoldersTest.php
+++ b/src/tests/Feature/Controller/SharedFoldersTest.php
@@ -1,650 +1,643 @@
 <?php
 
 namespace Tests\Feature\Controller;
 
 use App\SharedFolder;
 use App\Http\Controllers\API\V4\SharedFoldersController;
 use Carbon\Carbon;
 use Illuminate\Support\Facades\Queue;
 use Tests\TestCase;
 
 class SharedFoldersTest extends TestCase
 {
     /**
      * {@inheritDoc}
      */
     public function setUp(): void
     {
         parent::setUp();
 
         $this->deleteTestSharedFolder('folder-test@kolab.org');
         SharedFolder::where('name', 'like', 'Test_Folder')->forceDelete();
     }
 
     /**
      * {@inheritDoc}
      */
     public function tearDown(): void
     {
         $this->deleteTestSharedFolder('folder-test@kolab.org');
         SharedFolder::where('name', 'like', 'Test_Folder')->forceDelete();
 
         parent::tearDown();
     }
 
     /**
      * Test resource deleting (DELETE /api/v4/resources/<id>)
      */
     public function testDestroy(): void
     {
         $john = $this->getTestUser('john@kolab.org');
         $jack = $this->getTestUser('jack@kolab.org');
         $folder = $this->getTestSharedFolder('folder-test@kolab.org');
         $folder->assignToWallet($john->wallets->first());
 
         // Test unauth access
         $response = $this->delete("api/v4/shared-folders/{$folder->id}");
         $response->assertStatus(401);
 
         // Test non-existing folder
         $response = $this->actingAs($john)->delete("api/v4/shared-folders/abc");
         $response->assertStatus(404);
 
         // Test access to other user's folder
         $response = $this->actingAs($jack)->delete("api/v4/shared-folders/{$folder->id}");
         $response->assertStatus(403);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertSame("Access denied", $json['message']);
         $this->assertCount(2, $json);
 
         // Test removing a folder
         $response = $this->actingAs($john)->delete("api/v4/shared-folders/{$folder->id}");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertEquals('success', $json['status']);
         $this->assertEquals("Shared folder deleted successfully.", $json['message']);
     }
 
     /**
      * Test shared folders listing (GET /api/v4/shared-folders)
      */
     public function testIndex(): void
     {
         $jack = $this->getTestUser('jack@kolab.org');
         $john = $this->getTestUser('john@kolab.org');
         $ned = $this->getTestUser('ned@kolab.org');
 
         // Test unauth access
         $response = $this->get("api/v4/shared-folders");
         $response->assertStatus(401);
 
         // Test a user with no shared folders
         $response = $this->actingAs($jack)->get("/api/v4/shared-folders");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertCount(4, $json);
         $this->assertSame(0, $json['count']);
         $this->assertSame(false, $json['hasMore']);
         $this->assertSame("0 shared folders have been found.", $json['message']);
         $this->assertSame([], $json['list']);
 
         // Test a user with two shared folders
         $response = $this->actingAs($john)->get("/api/v4/shared-folders");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $folder = SharedFolder::where('name', 'Calendar')->first();
 
         $this->assertCount(4, $json);
         $this->assertSame(2, $json['count']);
         $this->assertSame(false, $json['hasMore']);
         $this->assertSame("2 shared folders have been found.", $json['message']);
         $this->assertCount(2, $json['list']);
         $this->assertSame($folder->id, $json['list'][0]['id']);
         $this->assertSame($folder->email, $json['list'][0]['email']);
         $this->assertSame($folder->name, $json['list'][0]['name']);
         $this->assertSame($folder->type, $json['list'][0]['type']);
         $this->assertArrayHasKey('isDeleted', $json['list'][0]);
         $this->assertArrayHasKey('isActive', $json['list'][0]);
-        $this->assertArrayHasKey('isLdapReady', $json['list'][0]);
-        if (\config('app.with_imap')) {
-            $this->assertArrayHasKey('isImapReady', $json['list'][0]);
+        $this->assertArrayHasKey('isImapReady', $json['list'][0]);
+        if (\config('app.with_ldap')) {
+            $this->assertArrayHasKey('isLdapReady', $json['list'][0]);
         }
 
         // Test that another wallet controller has access to shared folders
         $response = $this->actingAs($ned)->get("/api/v4/shared-folders");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertCount(4, $json);
         $this->assertSame(2, $json['count']);
         $this->assertSame(false, $json['hasMore']);
         $this->assertSame("2 shared folders have been found.", $json['message']);
         $this->assertCount(2, $json['list']);
         $this->assertSame($folder->email, $json['list'][0]['email']);
     }
 
     /**
      * Test shared folder config update (POST /api/v4/shared-folders/<folder>/config)
      */
     public function testSetConfig(): void
     {
         $john = $this->getTestUser('john@kolab.org');
         $jack = $this->getTestUser('jack@kolab.org');
         $folder = $this->getTestSharedFolder('folder-test@kolab.org');
         $folder->assignToWallet($john->wallets->first());
 
         // Test unknown resource id
         $post = ['acl' => ['john@kolab.org, full']];
         $response = $this->actingAs($john)->post("/api/v4/shared-folders/123/config", $post);
         $json = $response->json();
 
         $response->assertStatus(404);
 
         // Test access by user not being a wallet controller
         $response = $this->actingAs($jack)->post("/api/v4/shared-folders/{$folder->id}/config", $post);
         $json = $response->json();
 
         $response->assertStatus(403);
 
         $this->assertSame('error', $json['status']);
         $this->assertSame("Access denied", $json['message']);
         $this->assertCount(2, $json);
 
         // Test some invalid data
         $post = ['test' => 1];
         $response = $this->actingAs($john)->post("/api/v4/shared-folders/{$folder->id}/config", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(2, $json);
         $this->assertCount(1, $json['errors']);
         $this->assertSame('The requested configuration parameter is not supported.', $json['errors']['test']);
 
         $folder->refresh();
 
         $this->assertNull($folder->getSetting('test'));
         $this->assertNull($folder->getSetting('acl'));
 
         // Test some valid data
         $post = ['acl' => ['john@kolab.org, full']];
         $response = $this->actingAs($john)->post("/api/v4/shared-folders/{$folder->id}/config", $post);
 
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertCount(2, $json);
         $this->assertSame('success', $json['status']);
         $this->assertSame("Shared folder settings updated successfully.", $json['message']);
 
         $this->assertSame(['acl' => $post['acl']], $folder->fresh()->getConfig());
 
         // Test input validation
         $post = ['acl' => ['john@kolab.org, full', 'test, full']];
         $response = $this->actingAs($john)->post("/api/v4/shared-folders/{$folder->id}/config", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertCount(2, $json);
         $this->assertSame('error', $json['status']);
         $this->assertCount(1, $json['errors']);
         $this->assertCount(1, $json['errors']['acl']);
         $this->assertSame(
             "The specified email address is invalid.",
             $json['errors']['acl'][1]
         );
 
         $this->assertSame(['acl' => ['john@kolab.org, full']], $folder->fresh()->getConfig());
     }
 
     /**
      * Test fetching shared folder data/profile (GET /api/v4/shared-folders/<folder>)
      */
     public function testShow(): void
     {
         $jack = $this->getTestUser('jack@kolab.org');
         $john = $this->getTestUser('john@kolab.org');
         $ned = $this->getTestUser('ned@kolab.org');
 
         $folder = $this->getTestSharedFolder('folder-test@kolab.org');
         $folder->assignToWallet($john->wallets->first());
         $folder->setSetting('acl', '["anyone, full"]');
         $folder->setAliases(['folder-alias@kolab.org']);
 
         // Test unauthenticated access
         $response = $this->get("/api/v4/shared-folders/{$folder->id}");
         $response->assertStatus(401);
 
         // Test unauthorized access to a shared folder of another user
         $response = $this->actingAs($jack)->get("/api/v4/shared-folders/{$folder->id}");
         $response->assertStatus(403);
 
         // John: Account owner - non-existing folder
         $response = $this->actingAs($john)->get("/api/v4/shared-folders/abc");
         $response->assertStatus(404);
 
         // John: Account owner
         $response = $this->actingAs($john)->get("/api/v4/shared-folders/{$folder->id}");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame($folder->id, $json['id']);
         $this->assertSame($folder->email, $json['email']);
         $this->assertSame($folder->name, $json['name']);
         $this->assertSame($folder->type, $json['type']);
         $this->assertSame(['folder-alias@kolab.org'], $json['aliases']);
         $this->assertTrue(!empty($json['statusInfo']));
         $this->assertArrayHasKey('isDeleted', $json);
         $this->assertArrayHasKey('isActive', $json);
-        $this->assertArrayHasKey('isLdapReady', $json);
-        if (\config('app.with_imap')) {
-            $this->assertArrayHasKey('isImapReady', $json);
+        $this->assertArrayHasKey('isImapReady', $json);
+        if (\config('app.with_ldap')) {
+            $this->assertArrayHasKey('isLdapReady', $json);
         }
         $this->assertSame(['acl' => ['anyone, full']], $json['config']);
         $this->assertCount(1, $json['skus']);
     }
 
     /**
      * Test fetching SKUs list for a shared folder (GET /shared-folders/<id>/skus)
      */
     public function testSkus(): void
     {
         Queue::fake();
 
         $john = $this->getTestUser('john@kolab.org');
         $jack = $this->getTestUser('jack@kolab.org');
 
         $folder = $this->getTestSharedFolder('folder-test@kolab.org');
         $folder->assignToWallet($john->wallets->first());
 
         // Unauth access not allowed
         $response = $this->get("api/v4/shared-folders/{$folder->id}/skus");
         $response->assertStatus(401);
 
         // Unauthorized access not allowed
         $response = $this->actingAs($jack)->get("api/v4/shared-folders/{$folder->id}/skus");
         $response->assertStatus(403);
 
         // Non-existing folder
         $response = $this->actingAs($john)->get("api/v4/shared-folders/non-existing/skus");
         $response->assertStatus(404);
 
         $response = $this->actingAs($john)->get("api/v4/shared-folders/{$folder->id}/skus");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertCount(1, $json);
         $this->assertSkuElement('shared-folder', $json[0], [
                 'prio' => 0,
                 'type' => 'sharedFolder',
                 'handler' => 'SharedFolder',
                 'enabled' => true,
                 'readonly' => true,
         ]);
     }
 
     /**
      * Test fetching a shared folder status (GET /api/v4/shared-folders/<folder>/status)
      * and forcing setup process update (?refresh=1)
      */
     public function testStatus(): void
     {
         Queue::fake();
 
         $john = $this->getTestUser('john@kolab.org');
         $jack = $this->getTestUser('jack@kolab.org');
 
         $folder = $this->getTestSharedFolder('folder-test@kolab.org');
         $folder->assignToWallet($john->wallets->first());
 
         // Test unauthorized access
         $response = $this->get("/api/v4/shared-folders/abc/status");
         $response->assertStatus(401);
 
         // Test unauthorized access
         $response = $this->actingAs($jack)->get("/api/v4/shared-folders/{$folder->id}/status");
         $response->assertStatus(403);
 
         $folder->status = SharedFolder::STATUS_NEW | SharedFolder::STATUS_ACTIVE;
         $folder->save();
 
         // Get resource status
         $response = $this->actingAs($john)->get("/api/v4/shared-folders/{$folder->id}/status");
         $response->assertStatus(200);
 
         $json = $response->json();
 
-        $this->assertFalse($json['isLdapReady']);
+        $this->assertFalse($json['isImapReady']);
         $this->assertFalse($json['isReady']);
         $this->assertFalse($json['isDeleted']);
         $this->assertTrue($json['isActive']);
-        if (\config('app.with_imap')) {
-            $this->assertFalse($json['isImapReady']);
-            $this->assertCount(7, $json['process']);
-        } else {
-            $this->assertCount(6, $json['process']);
-        }
-        $this->assertSame('shared-folder-new', $json['process'][0]['label']);
-        $this->assertSame(true, $json['process'][0]['state']);
-        $this->assertSame('shared-folder-ldap-ready', $json['process'][1]['label']);
-        $this->assertSame(false, $json['process'][1]['state']);
+        $this->assertSame('running', $json['processState']);
         $this->assertTrue(empty($json['status']));
         $this->assertTrue(empty($json['message']));
-        $this->assertSame('running', $json['processState']);
+        $this->assertSame('shared-folder-new', $json['process'][0]['label']);
+        $this->assertSame(true, $json['process'][0]['state']);
+        if (\config('app.with_ldap')) {
+            $this->assertFalse($json['isLdapReady']);
+            $this->assertSame('shared-folder-ldap-ready', $json['process'][1]['label']);
+            $this->assertSame(false, $json['process'][1]['state']);
+        }
 
         // Make sure the domain is confirmed (other test might unset that status)
         $domain = $this->getTestDomain('kolab.org');
         $domain->status |= \App\Domain::STATUS_CONFIRMED;
         $domain->save();
         $folder->status |= SharedFolder::STATUS_IMAP_READY;
         $folder->save();
 
         // Now "reboot" the process
         Queue::fake();
         $response = $this->actingAs($john)->get("/api/v4/shared-folders/{$folder->id}/status?refresh=1");
         $response->assertStatus(200);
 
         $json = $response->json();
 
-        $this->assertFalse($json['isLdapReady']);
+        $this->assertTrue($json['isImapReady']);
         $this->assertFalse($json['isReady']);
-        if (\config('app.with_imap')) {
-            $this->assertTrue($json['isImapReady']);
-            $this->assertCount(7, $json['process']);
-        } else {
-            $this->assertCount(6, $json['process']);
-        }
-        $this->assertSame('shared-folder-ldap-ready', $json['process'][1]['label']);
-        $this->assertSame(false, $json['process'][1]['state']);
-        if (\config('app.with_imap')) {
+        if (\config('app.with_ldap')) {
+            $this->assertFalse($json['isLdapReady']);
+            $this->assertSame('shared-folder-ldap-ready', $json['process'][1]['label']);
+            $this->assertSame(false, $json['process'][1]['state']);
             $this->assertSame('shared-folder-imap-ready', $json['process'][2]['label']);
             $this->assertSame(true, $json['process'][2]['state']);
+        } else {
+            $this->assertSame('shared-folder-imap-ready', $json['process'][1]['label']);
+            $this->assertSame(true, $json['process'][1]['state']);
         }
         $this->assertSame('success', $json['status']);
         $this->assertSame('Setup process has been pushed. Please wait.', $json['message']);
         $this->assertSame('waiting', $json['processState']);
 
         Queue::assertPushed(\App\Jobs\SharedFolder\CreateJob::class, 1);
 
         // Test a case when a domain is not ready
         Queue::fake();
         $domain->status ^= \App\Domain::STATUS_CONFIRMED;
         $domain->save();
 
         $response = $this->actingAs($john)->get("/api/v4/shared-folders/{$folder->id}/status?refresh=1");
         $response->assertStatus(200);
 
         $json = $response->json();
 
-        $this->assertFalse($json['isLdapReady']);
+        $this->assertTrue($json['isImapReady']);
         $this->assertFalse($json['isReady']);
-        if (\config('app.with_imap')) {
-            $this->assertCount(7, $json['process']);
+        if (\config('app.with_ldap')) {
+            $this->assertFalse($json['isLdapReady']);
+            $this->assertSame('shared-folder-ldap-ready', $json['process'][1]['label']);
+            $this->assertSame(false, $json['process'][1]['state']);
         } else {
-            $this->assertCount(6, $json['process']);
+            $this->assertSame('shared-folder-imap-ready', $json['process'][1]['label']);
+            $this->assertSame(true, $json['process'][1]['state']);
         }
-        $this->assertSame('shared-folder-ldap-ready', $json['process'][1]['label']);
-        $this->assertSame(false, $json['process'][1]['state']);
         $this->assertSame('success', $json['status']);
         $this->assertSame('Setup process has been pushed. Please wait.', $json['message']);
         $this->assertSame('waiting', $json['processState']);
 
         Queue::assertPushed(\App\Jobs\SharedFolder\CreateJob::class, 1);
     }
 
     /**
      * Test SharedFoldersController::statusInfo()
      */
     public function testStatusInfo(): void
     {
         $john = $this->getTestUser('john@kolab.org');
         $folder = $this->getTestSharedFolder('folder-test@kolab.org');
         $folder->assignToWallet($john->wallets->first());
         $folder->status = SharedFolder::STATUS_NEW | SharedFolder::STATUS_ACTIVE;
         $folder->save();
         $domain = $this->getTestDomain('kolab.org');
         $domain->status |= \App\Domain::STATUS_CONFIRMED;
         $domain->save();
 
         $result = SharedFoldersController::statusInfo($folder);
 
-        $this->assertFalse($result['isReady']);
-        if (\config('app.with_imap')) {
-            $this->assertCount(7, $result['process']);
-        } else {
-            $this->assertCount(6, $result['process']);
-        }
+        $this->assertFalse($result['isDone']);
+        $this->assertSame('running', $result['processState']);
         $this->assertSame('shared-folder-new', $result['process'][0]['label']);
         $this->assertSame(true, $result['process'][0]['state']);
-        $this->assertSame('shared-folder-ldap-ready', $result['process'][1]['label']);
-        $this->assertSame(false, $result['process'][1]['state']);
-        $this->assertSame('running', $result['processState']);
+        if (\config('app.with_ldap')) {
+            $this->assertSame('shared-folder-ldap-ready', $result['process'][1]['label']);
+            $this->assertSame(false, $result['process'][1]['state']);
+        }
 
         $folder->created_at = Carbon::now()->subSeconds(181);
         $folder->save();
 
         $result = SharedFoldersController::statusInfo($folder);
 
         $this->assertSame('failed', $result['processState']);
 
         $folder->status |= SharedFolder::STATUS_LDAP_READY | SharedFolder::STATUS_IMAP_READY;
         $folder->save();
 
         $result = SharedFoldersController::statusInfo($folder);
 
-        $this->assertTrue($result['isReady']);
-        if (\config('app.with_imap')) {
-            $this->assertCount(7, $result['process']);
-        } else {
-            $this->assertCount(6, $result['process']);
-        }
+        $this->assertTrue($result['isDone']);
+        $this->assertSame('done', $result['processState']);
         $this->assertSame('shared-folder-new', $result['process'][0]['label']);
         $this->assertSame(true, $result['process'][0]['state']);
-        $this->assertSame('shared-folder-ldap-ready', $result['process'][1]['label']);
-        $this->assertSame(true, $result['process'][1]['state']);
-        $this->assertSame('shared-folder-ldap-ready', $result['process'][1]['label']);
-        $this->assertSame(true, $result['process'][1]['state']);
-        $this->assertSame('done', $result['processState']);
+        if (\config('app.with_ldap')) {
+            $this->assertSame('shared-folder-ldap-ready', $result['process'][1]['label']);
+            $this->assertSame(true, $result['process'][1]['state']);
+            $this->assertSame('shared-folder-imap-ready', $result['process'][2]['label']);
+            $this->assertSame(true, $result['process'][2]['state']);
+        } else {
+            $this->assertSame('shared-folder-imap-ready', $result['process'][1]['label']);
+            $this->assertSame(true, $result['process'][1]['state']);
+        }
     }
 
     /**
      * Test shared folder creation (POST /api/v4/shared-folders)
      */
     public function testStore(): void
     {
         Queue::fake();
 
         $jack = $this->getTestUser('jack@kolab.org');
         $john = $this->getTestUser('john@kolab.org');
 
         // Test unauth request
         $response = $this->post("/api/v4/shared-folders", []);
         $response->assertStatus(401);
 
         // Test non-controller user
         $response = $this->actingAs($jack)->post("/api/v4/shared-folders", []);
         $response->assertStatus(403);
 
         // Test empty request
         $response = $this->actingAs($john)->post("/api/v4/shared-folders", []);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertSame("The name field is required.", $json['errors']['name'][0]);
         $this->assertSame("The type field is required.", $json['errors']['type'][0]);
         $this->assertCount(2, $json);
         $this->assertCount(2, $json['errors']);
 
         // Test too long name, invalid alias domain
         $post = [
             'domain' => 'kolab.org',
             'name' => str_repeat('A', 192),
             'type' => 'unknown',
             'aliases' => ['folder-alias@unknown.org'],
         ];
 
         $response = $this->actingAs($john)->post("/api/v4/shared-folders", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(2, $json);
         $this->assertSame(["The name may not be greater than 191 characters."], $json['errors']['name']);
         $this->assertSame(["The specified type is invalid."], $json['errors']['type']);
         $this->assertSame(["The specified domain is invalid."], $json['errors']['aliases']);
         $this->assertCount(3, $json['errors']);
 
         // Test successful folder creation
         $post['name'] = 'Test Folder';
         $post['type'] = 'event';
         $post['aliases'] = [];
 
         $response = $this->actingAs($john)->post("/api/v4/shared-folders", $post);
         $json = $response->json();
 
         $response->assertStatus(200);
 
         $this->assertSame('success', $json['status']);
         $this->assertSame("Shared folder created successfully.", $json['message']);
         $this->assertCount(2, $json);
 
         $folder = SharedFolder::where('name', $post['name'])->first();
         $this->assertInstanceOf(SharedFolder::class, $folder);
         $this->assertSame($post['type'], $folder->type);
         $this->assertTrue($john->sharedFolders()->get()->contains($folder));
         $this->assertSame([], $folder->aliases()->pluck('alias')->all());
 
         // Shared folder name must be unique within a domain
         $post['type'] = 'mail';
         $response = $this->actingAs($john)->post("/api/v4/shared-folders", $post);
         $response->assertStatus(422);
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(2, $json);
         $this->assertCount(1, $json['errors']);
         $this->assertSame("The specified name is not available.", $json['errors']['name'][0]);
 
         $folder->forceDelete();
 
         // Test successful folder creation with aliases
         $post['name'] = 'Test Folder';
         $post['type'] = 'mail';
         $post['aliases'] = ['folder-alias@kolab.org'];
         $response = $this->actingAs($john)->post("/api/v4/shared-folders", $post);
         $json = $response->json();
 
         $response->assertStatus(200);
 
         $folder = SharedFolder::where('name', $post['name'])->first();
         $this->assertSame(['folder-alias@kolab.org'], $folder->aliases()->pluck('alias')->all());
 
         $folder->forceDelete();
 
         // Test handling subfolders and lmtp alias email
         $post['name'] = 'Test/Folder';
         $post['type'] = 'mail';
         $post['aliases'] = ['shared+shared/Test/Folder@kolab.org'];
         $response = $this->actingAs($john)->post("/api/v4/shared-folders", $post);
         $json = $response->json();
 
         $response->assertStatus(200);
 
         $folder = SharedFolder::where('name', $post['name'])->first();
         $this->assertSame(['shared+shared/Test/Folder@kolab.org'], $folder->aliases()->pluck('alias')->all());
     }
 
     /**
      * Test shared folder update (PUT /api/v4/shared-folders/<folder)
      */
     public function testUpdate(): void
     {
         Queue::fake();
 
         $jack = $this->getTestUser('jack@kolab.org');
         $john = $this->getTestUser('john@kolab.org');
         $ned = $this->getTestUser('ned@kolab.org');
 
         $folder = $this->getTestSharedFolder('folder-test@kolab.org');
         $folder->assignToWallet($john->wallets->first());
 
         // Test unauthorized update
         $response = $this->get("/api/v4/shared-folders/{$folder->id}", []);
         $response->assertStatus(401);
 
         // Test unauthorized update
         $response = $this->actingAs($jack)->get("/api/v4/shared-folders/{$folder->id}", []);
         $response->assertStatus(403);
 
         // Name change
         $post = [
             'name' => 'Test Res',
         ];
 
         $response = $this->actingAs($john)->put("/api/v4/shared-folders/{$folder->id}", $post);
         $json = $response->json();
 
         $response->assertStatus(200);
 
         $this->assertSame('success', $json['status']);
         $this->assertSame("Shared folder updated successfully.", $json['message']);
         $this->assertCount(2, $json);
 
         $folder->refresh();
         $this->assertSame($post['name'], $folder->name);
 
         // Aliases with error
         $post['aliases'] = ['folder-alias1@kolab.org', 'folder-alias2@unknown.com'];
 
         $response = $this->actingAs($john)->put("/api/v4/shared-folders/{$folder->id}", $post);
         $json = $response->json();
 
         $response->assertStatus(422);
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(2, $json);
         $this->assertCount(1, $json['errors']);
         $this->assertCount(1, $json['errors']['aliases']);
         $this->assertSame("The specified domain is invalid.", $json['errors']['aliases'][1]);
         $this->assertSame([], $folder->aliases()->pluck('alias')->all());
 
         // Aliases with success expected
         $post['aliases'] = ['folder-alias1@kolab.org', 'folder-alias2@kolab.org'];
 
         $response = $this->actingAs($john)->put("/api/v4/shared-folders/{$folder->id}", $post);
         $json = $response->json();
 
         $response->assertStatus(200);
 
         $this->assertSame('success', $json['status']);
         $this->assertSame("Shared folder updated successfully.", $json['message']);
         $this->assertCount(2, $json);
         $this->assertSame($post['aliases'], $folder->aliases()->pluck('alias')->all());
 
         // All aliases removal
         $post['aliases'] = [];
 
         $response = $this->actingAs($john)->put("/api/v4/shared-folders/{$folder->id}", $post);
         $response->assertStatus(200);
 
         $this->assertSame($post['aliases'], $folder->aliases()->pluck('alias')->all());
     }
 }
diff --git a/src/tests/Feature/Controller/UsersTest.php b/src/tests/Feature/Controller/UsersTest.php
index b5c85e45..ff719999 100644
--- a/src/tests/Feature/Controller/UsersTest.php
+++ b/src/tests/Feature/Controller/UsersTest.php
@@ -1,1669 +1,1666 @@
 <?php
 
 namespace Tests\Feature\Controller;
 
 use App\Discount;
 use App\Domain;
 use App\Http\Controllers\API\V4\UsersController;
 use App\Package;
 use App\Sku;
 use App\Tenant;
 use App\User;
 use App\Wallet;
 use Carbon\Carbon;
 use Illuminate\Support\Facades\Queue;
 use Illuminate\Support\Str;
 use Tests\TestCase;
 
 class UsersTest extends TestCase
 {
     /**
      * {@inheritDoc}
      */
     public function setUp(): void
     {
         parent::setUp();
 
         $this->clearBetaEntitlements();
         $this->deleteTestUser('jane@kolabnow.com');
         $this->deleteTestUser('UsersControllerTest1@userscontroller.com');
         $this->deleteTestUser('UsersControllerTest2@userscontroller.com');
         $this->deleteTestUser('UsersControllerTest3@userscontroller.com');
         $this->deleteTestUser('UserEntitlement2A@UserEntitlement.com');
         $this->deleteTestUser('john2.doe2@kolab.org');
         $this->deleteTestUser('deleted@kolab.org');
         $this->deleteTestUser('deleted@kolabnow.com');
         $this->deleteTestDomain('userscontroller.com');
         $this->deleteTestGroup('group-test@kolabnow.com');
         $this->deleteTestGroup('group-test@kolab.org');
         $this->deleteTestSharedFolder('folder-test@kolabnow.com');
         $this->deleteTestResource('resource-test@kolabnow.com');
         Sku::where('title', 'test')->delete();
 
         $user = $this->getTestUser('john@kolab.org');
         $wallet = $user->wallets()->first();
         $wallet->discount()->dissociate();
         $wallet->settings()->whereIn('key', ['mollie_id', 'stripe_id'])->delete();
         $wallet->save();
         $user->settings()->whereIn('key', ['greylist_enabled', 'guam_enabled'])->delete();
         $user->status |= User::STATUS_IMAP_READY;
         $user->save();
     }
 
     /**
      * {@inheritDoc}
      */
     public function tearDown(): void
     {
         $this->clearBetaEntitlements();
         $this->deleteTestUser('jane@kolabnow.com');
         $this->deleteTestUser('UsersControllerTest1@userscontroller.com');
         $this->deleteTestUser('UsersControllerTest2@userscontroller.com');
         $this->deleteTestUser('UsersControllerTest3@userscontroller.com');
         $this->deleteTestUser('UserEntitlement2A@UserEntitlement.com');
         $this->deleteTestUser('john2.doe2@kolab.org');
         $this->deleteTestUser('deleted@kolab.org');
         $this->deleteTestUser('deleted@kolabnow.com');
         $this->deleteTestDomain('userscontroller.com');
         $this->deleteTestGroup('group-test@kolabnow.com');
         $this->deleteTestGroup('group-test@kolab.org');
         $this->deleteTestSharedFolder('folder-test@kolabnow.com');
         $this->deleteTestResource('resource-test@kolabnow.com');
         Sku::where('title', 'test')->delete();
 
         $user = $this->getTestUser('john@kolab.org');
         $wallet = $user->wallets()->first();
         $wallet->discount()->dissociate();
         $wallet->settings()->whereIn('key', ['mollie_id', 'stripe_id'])->delete();
         $wallet->save();
         $user->settings()->whereIn('key', ['greylist_enabled', 'guam_enabled'])->delete();
         $user->status |= User::STATUS_IMAP_READY;
         $user->save();
 
         parent::tearDown();
     }
 
     /**
      * Test user deleting (DELETE /api/v4/users/<id>)
      */
     public function testDestroy(): void
     {
         // First create some users/accounts to delete
         $package_kolab = \App\Package::where('title', 'kolab')->first();
         $package_domain = \App\Package::where('title', 'domain-hosting')->first();
 
         $john = $this->getTestUser('john@kolab.org');
         $user1 = $this->getTestUser('UsersControllerTest1@userscontroller.com');
         $user2 = $this->getTestUser('UsersControllerTest2@userscontroller.com');
         $user3 = $this->getTestUser('UsersControllerTest3@userscontroller.com');
         $domain = $this->getTestDomain('userscontroller.com', [
                 'status' => Domain::STATUS_NEW,
                 'type' => Domain::TYPE_PUBLIC,
         ]);
         $user1->assignPackage($package_kolab);
         $domain->assignPackage($package_domain, $user1);
         $user1->assignPackage($package_kolab, $user2);
         $user1->assignPackage($package_kolab, $user3);
 
         // Test unauth access
         $response = $this->delete("api/v4/users/{$user2->id}");
         $response->assertStatus(401);
 
         // Test access to other user/account
         $response = $this->actingAs($john)->delete("api/v4/users/{$user2->id}");
         $response->assertStatus(403);
         $response = $this->actingAs($john)->delete("api/v4/users/{$user1->id}");
         $response->assertStatus(403);
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertSame("Access denied", $json['message']);
         $this->assertCount(2, $json);
 
         // Test that non-controller cannot remove himself
         $response = $this->actingAs($user3)->delete("api/v4/users/{$user3->id}");
         $response->assertStatus(403);
 
         // Test removing a non-controller user
         $response = $this->actingAs($user1)->delete("api/v4/users/{$user3->id}");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertEquals('success', $json['status']);
         $this->assertEquals('User deleted successfully.', $json['message']);
 
         // Test removing self (an account with users)
         $response = $this->actingAs($user1)->delete("api/v4/users/{$user1->id}");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertEquals('success', $json['status']);
         $this->assertEquals('User deleted successfully.', $json['message']);
     }
 
     /**
      * Test user deleting (DELETE /api/v4/users/<id>)
      */
     public function testDestroyByController(): void
     {
         // Create an account with additional controller - $user2
         $package_kolab = \App\Package::where('title', 'kolab')->first();
         $package_domain = \App\Package::where('title', 'domain-hosting')->first();
         $user1 = $this->getTestUser('UsersControllerTest1@userscontroller.com');
         $user2 = $this->getTestUser('UsersControllerTest2@userscontroller.com');
         $user3 = $this->getTestUser('UsersControllerTest3@userscontroller.com');
         $domain = $this->getTestDomain('userscontroller.com', [
                 'status' => Domain::STATUS_NEW,
                 'type' => Domain::TYPE_PUBLIC,
         ]);
         $user1->assignPackage($package_kolab);
         $domain->assignPackage($package_domain, $user1);
         $user1->assignPackage($package_kolab, $user2);
         $user1->assignPackage($package_kolab, $user3);
         $user1->wallets()->first()->addController($user2);
 
         // TODO/FIXME:
         //   For now controller can delete himself, as well as
         //   the whole account he has control to, including the owner
         //   Probably he should not be able to do none of those
         //   However, this is not 0-regression scenario as we
         //   do not fully support additional controllers.
 
         //$response = $this->actingAs($user2)->delete("api/v4/users/{$user2->id}");
         //$response->assertStatus(403);
 
         $response = $this->actingAs($user2)->delete("api/v4/users/{$user3->id}");
         $response->assertStatus(200);
 
         $response = $this->actingAs($user2)->delete("api/v4/users/{$user1->id}");
         $response->assertStatus(200);
 
         // Note: More detailed assertions in testDestroy() above
 
         $this->assertTrue($user1->fresh()->trashed());
         $this->assertTrue($user2->fresh()->trashed());
         $this->assertTrue($user3->fresh()->trashed());
     }
 
     /**
      * Test user listing (GET /api/v4/users)
      */
     public function testIndex(): void
     {
         // Test unauth access
         $response = $this->get("api/v4/users");
         $response->assertStatus(401);
 
         $jack = $this->getTestUser('jack@kolab.org');
         $joe = $this->getTestUser('joe@kolab.org');
         $john = $this->getTestUser('john@kolab.org');
         $ned = $this->getTestUser('ned@kolab.org');
 
         $response = $this->actingAs($jack)->get("/api/v4/users");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame(false, $json['hasMore']);
         $this->assertSame(0, $json['count']);
         $this->assertCount(0, $json['list']);
 
         $response = $this->actingAs($john)->get("/api/v4/users");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame(false, $json['hasMore']);
         $this->assertSame(4, $json['count']);
         $this->assertCount(4, $json['list']);
         $this->assertSame($jack->email, $json['list'][0]['email']);
         $this->assertSame($joe->email, $json['list'][1]['email']);
         $this->assertSame($john->email, $json['list'][2]['email']);
         $this->assertSame($ned->email, $json['list'][3]['email']);
         // Values below are tested by Unit tests
         $this->assertArrayHasKey('isDeleted', $json['list'][0]);
         $this->assertArrayHasKey('isDegraded', $json['list'][0]);
         $this->assertArrayHasKey('isAccountDegraded', $json['list'][0]);
         $this->assertArrayHasKey('isSuspended', $json['list'][0]);
         $this->assertArrayHasKey('isActive', $json['list'][0]);
         $this->assertArrayHasKey('isReady', $json['list'][0]);
+        $this->assertArrayHasKey('isImapReady', $json['list'][0]);
         if (\config('app.with_ldap')) {
             $this->assertArrayHasKey('isLdapReady', $json['list'][0]);
-        }
-        if (\config('app.with_imap')) {
-            $this->assertArrayHasKey('isImapReady', $json['list'][0]);
+        } else {
+            $this->assertArrayNotHasKey('isLdapReady', $json['list'][0]);
         }
 
         $response = $this->actingAs($ned)->get("/api/v4/users");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame(false, $json['hasMore']);
         $this->assertSame(4, $json['count']);
         $this->assertCount(4, $json['list']);
         $this->assertSame($jack->email, $json['list'][0]['email']);
         $this->assertSame($joe->email, $json['list'][1]['email']);
         $this->assertSame($john->email, $json['list'][2]['email']);
         $this->assertSame($ned->email, $json['list'][3]['email']);
 
         // Search by user email
         $response = $this->actingAs($john)->get("/api/v4/users?search=jack@k");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame(false, $json['hasMore']);
         $this->assertSame(1, $json['count']);
         $this->assertCount(1, $json['list']);
         $this->assertSame($jack->email, $json['list'][0]['email']);
 
         // Search by alias
         $response = $this->actingAs($john)->get("/api/v4/users?search=monster");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame(false, $json['hasMore']);
         $this->assertSame(1, $json['count']);
         $this->assertCount(1, $json['list']);
         $this->assertSame($joe->email, $json['list'][0]['email']);
 
         // Search by name
         $response = $this->actingAs($john)->get("/api/v4/users?search=land");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame(false, $json['hasMore']);
         $this->assertSame(1, $json['count']);
         $this->assertCount(1, $json['list']);
         $this->assertSame($ned->email, $json['list'][0]['email']);
 
         // TODO: Test paging
     }
 
     /**
      * Test fetching user data/profile (GET /api/v4/users/<user-id>)
      */
     public function testShow(): void
     {
         $userA = $this->getTestUser('UserEntitlement2A@UserEntitlement.com');
 
         // Test getting profile of self
         $response = $this->actingAs($userA)->get("/api/v4/users/{$userA->id}");
 
         $json = $response->json();
 
         $response->assertStatus(200);
         $this->assertEquals($userA->id, $json['id']);
         $this->assertEquals($userA->email, $json['email']);
         $this->assertTrue(is_array($json['statusInfo']));
         $this->assertTrue(is_array($json['settings']));
         $this->assertTrue($json['config']['greylist_enabled']);
         $this->assertFalse($json['config']['guam_enabled']);
         $this->assertSame([], $json['skus']);
         $this->assertSame([], $json['aliases']);
         // Values below are tested by Unit tests
         $this->assertArrayHasKey('isDeleted', $json);
         $this->assertArrayHasKey('isDegraded', $json);
         $this->assertArrayHasKey('isAccountDegraded', $json);
         $this->assertArrayHasKey('isSuspended', $json);
         $this->assertArrayHasKey('isActive', $json);
         $this->assertArrayHasKey('isReady', $json);
+        $this->assertArrayHasKey('isImapReady', $json);
         if (\config('app.with_ldap')) {
             $this->assertArrayHasKey('isLdapReady', $json);
-        }
-        if (\config('app.with_imap')) {
-            $this->assertArrayHasKey('isImapReady', $json);
+        } else {
+            $this->assertArrayNotHasKey('isLdapReady', $json);
         }
 
         $john = $this->getTestUser('john@kolab.org');
         $jack = $this->getTestUser('jack@kolab.org');
         $ned = $this->getTestUser('ned@kolab.org');
 
         // Test unauthorized access to a profile of other user
         $response = $this->actingAs($jack)->get("/api/v4/users/{$userA->id}");
         $response->assertStatus(403);
 
         // Test authorized access to a profile of other user
         // Ned: Additional account controller
         $response = $this->actingAs($ned)->get("/api/v4/users/{$john->id}");
         $response->assertStatus(200);
 
         $json = $response->json();
         $this->assertSame(['john.doe@kolab.org'], $json['aliases']);
 
         $response = $this->actingAs($ned)->get("/api/v4/users/{$jack->id}");
         $response->assertStatus(200);
 
         // John: Account owner
         $response = $this->actingAs($john)->get("/api/v4/users/{$jack->id}");
         $response->assertStatus(200);
         $response = $this->actingAs($john)->get("/api/v4/users/{$ned->id}");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $storage_sku = Sku::withEnvTenantContext()->where('title', 'storage')->first();
         $groupware_sku = Sku::withEnvTenantContext()->where('title', 'groupware')->first();
         $mailbox_sku = Sku::withEnvTenantContext()->where('title', 'mailbox')->first();
         $secondfactor_sku = Sku::withEnvTenantContext()->where('title', '2fa')->first();
 
         $this->assertCount(5, $json['skus']);
 
         $this->assertSame(5, $json['skus'][$storage_sku->id]['count']);
         $this->assertSame([0,0,0,0,0], $json['skus'][$storage_sku->id]['costs']);
         $this->assertSame(1, $json['skus'][$groupware_sku->id]['count']);
         $this->assertSame([490], $json['skus'][$groupware_sku->id]['costs']);
         $this->assertSame(1, $json['skus'][$mailbox_sku->id]['count']);
         $this->assertSame([500], $json['skus'][$mailbox_sku->id]['costs']);
         $this->assertSame(1, $json['skus'][$secondfactor_sku->id]['count']);
         $this->assertSame([0], $json['skus'][$secondfactor_sku->id]['costs']);
 
         $this->assertSame([], $json['aliases']);
     }
 
     /**
      * Test fetching SKUs list for a user (GET /users/<id>/skus)
      */
     public function testSkus(): void
     {
         $user = $this->getTestUser('john@kolab.org');
 
         // Unauth access not allowed
         $response = $this->get("api/v4/users/{$user->id}/skus");
         $response->assertStatus(401);
 
         // Create an sku for another tenant, to make sure it is not included in the result
         $nsku = Sku::create([
                 'title' => 'test',
                 'name' => 'Test',
                 'description' => '',
                 'active' => true,
                 'cost' => 100,
                 'handler_class' => 'Mailbox',
         ]);
         $tenant = Tenant::whereNotIn('id', [\config('app.tenant_id')])->first();
         $nsku->tenant_id = $tenant->id;
         $nsku->save();
 
         $response = $this->actingAs($user)->get("api/v4/users/{$user->id}/skus");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertCount(5, $json);
 
         $this->assertSkuElement('mailbox', $json[0], [
                 'prio' => 100,
                 'type' => 'user',
                 'handler' => 'Mailbox',
                 'enabled' => true,
                 'readonly' => true,
         ]);
 
         $this->assertSkuElement('storage', $json[1], [
                 'prio' => 90,
                 'type' => 'user',
                 'handler' => 'Storage',
                 'enabled' => true,
                 'readonly' => true,
                 'range' => [
                     'min' => 5,
                     'max' => 100,
                     'unit' => 'GB',
                 ]
         ]);
 
         $this->assertSkuElement('groupware', $json[2], [
                 'prio' => 80,
                 'type' => 'user',
                 'handler' => 'Groupware',
                 'enabled' => false,
                 'readonly' => false,
         ]);
 
         $this->assertSkuElement('activesync', $json[3], [
                 'prio' => 70,
                 'type' => 'user',
                 'handler' => 'Activesync',
                 'enabled' => false,
                 'readonly' => false,
                 'required' => ['Groupware'],
         ]);
 
         $this->assertSkuElement('2fa', $json[4], [
                 'prio' => 60,
                 'type' => 'user',
                 'handler' => 'Auth2F',
                 'enabled' => false,
                 'readonly' => false,
                 'forbidden' => ['Activesync'],
         ]);
 
         // Test inclusion of beta SKUs
         $sku = Sku::withEnvTenantContext()->where('title', 'beta')->first();
         $user->assignSku($sku);
         $response = $this->actingAs($user)->get("api/v4/users/{$user->id}/skus");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertCount(6, $json);
 
         $this->assertSkuElement('beta', $json[5], [
                 'prio' => 10,
                 'type' => 'user',
                 'handler' => 'Beta',
                 'enabled' => false,
                 'readonly' => false,
         ]);
     }
 
     /**
      * Test fetching user status (GET /api/v4/users/<user-id>/status)
      * and forcing setup process update (?refresh=1)
      *
      * @group imap
      * @group dns
      */
     public function testStatus(): void
     {
         Queue::fake();
 
         $john = $this->getTestUser('john@kolab.org');
         $jack = $this->getTestUser('jack@kolab.org');
 
         // Test unauthorized access
         $response = $this->actingAs($jack)->get("/api/v4/users/{$john->id}/status");
         $response->assertStatus(403);
 
         $john->status &= ~User::STATUS_IMAP_READY;
         $john->status &= ~User::STATUS_LDAP_READY;
         $john->save();
 
         // Get user status
         $response = $this->actingAs($john)->get("/api/v4/users/{$john->id}/status");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertFalse($json['isReady']);
+        $this->assertFalse($json['isImapReady']);
+        $this->assertTrue(empty($json['status']));
+        $this->assertTrue(empty($json['message']));
 
         if (\config('app.with_ldap')) {
             $this->assertFalse($json['isLdapReady']);
-        } else {
-            $this->assertArrayNotHasKey('isLdapReady', $json);
-        }
-
-        if (\config('app.with_imap')) {
-            $this->assertFalse($json['isImapReady']);
+            $this->assertSame('user-ldap-ready', $json['process'][1]['label']);
+            $this->assertFalse($json['process'][1]['state']);
             $this->assertSame('user-imap-ready', $json['process'][2]['label']);
             $this->assertFalse($json['process'][2]['state']);
         } else {
-            $this->assertArrayNotHasKey('isImapReady', $json);
+            $this->assertArrayNotHasKey('isLdapReady', $json);
+            $this->assertSame('user-imap-ready', $json['process'][1]['label']);
+            $this->assertFalse($json['process'][1]['state']);
         }
-        $this->assertTrue(empty($json['status']));
-        $this->assertTrue(empty($json['message']));
 
         // Make sure the domain is confirmed (other test might unset that status)
         $domain = $this->getTestDomain('kolab.org');
         $domain->status |= Domain::STATUS_CONFIRMED;
         $domain->save();
 
         // Now "reboot" the process
         Queue::fake();
         $response = $this->actingAs($john)->get("/api/v4/users/{$john->id}/status?refresh=1");
         $response->assertStatus(200);
 
         $json = $response->json();
 
-        $this->assertFalse($json['isLdapReady']);
+        $this->assertFalse($json['isImapReady']);
         $this->assertFalse($json['isReady']);
-        if (\config('app.with_imap')) {
-            $this->assertFalse($json['isImapReady']);
+        $this->assertSame('success', $json['status']);
+        $this->assertSame('Setup process has been pushed. Please wait.', $json['message']);
+
+        if (\config('app.with_ldap')) {
+            $this->assertFalse($json['isLdapReady']);
+            $this->assertSame('user-ldap-ready', $json['process'][1]['label']);
+            $this->assertSame(false, $json['process'][1]['state']);
             $this->assertSame('user-imap-ready', $json['process'][2]['label']);
             $this->assertSame(false, $json['process'][2]['state']);
+        } else {
+            $this->assertSame('user-imap-ready', $json['process'][1]['label']);
+            $this->assertSame(false, $json['process'][1]['state']);
         }
-        $this->assertSame('success', $json['status']);
-        $this->assertSame('Setup process has been pushed. Please wait.', $json['message']);
 
         Queue::assertPushed(\App\Jobs\User\CreateJob::class, 1);
     }
 
     /**
      * Test UsersController::statusInfo()
      */
     public function testStatusInfo(): void
     {
         $user = $this->getTestUser('UsersControllerTest1@userscontroller.com');
         $domain = $this->getTestDomain('userscontroller.com', [
                 'status' => Domain::STATUS_NEW,
                 'type' => Domain::TYPE_PUBLIC,
         ]);
 
         $user->created_at = Carbon::now();
         $user->status = User::STATUS_NEW;
         $user->save();
 
         $result = UsersController::statusInfo($user);
 
-        $this->assertFalse($result['isReady']);
+        $this->assertFalse($result['isDone']);
         $this->assertSame([], $result['skus']);
-        if (\config('app.with_imap')) {
-            $this->assertCount(3, $result['process']);
-        } else {
-            $this->assertCount(2, $result['process']);
-        }
+        $this->assertCount(3, $result['process']);
         $this->assertSame('user-new', $result['process'][0]['label']);
         $this->assertSame(true, $result['process'][0]['state']);
-        $this->assertSame('user-ldap-ready', $result['process'][1]['label']);
-        $this->assertSame(false, $result['process'][1]['state']);
-        if (\config('app.with_imap')) {
+        if (\config('app.with_ldap')) {
+            $this->assertSame('user-ldap-ready', $result['process'][1]['label']);
+            $this->assertSame(false, $result['process'][1]['state']);
             $this->assertSame('user-imap-ready', $result['process'][2]['label']);
             $this->assertSame(false, $result['process'][2]['state']);
+        } else {
+            $this->assertSame('user-imap-ready', $result['process'][1]['label']);
+            $this->assertSame(false, $result['process'][1]['state']);
         }
         $this->assertSame('running', $result['processState']);
         $this->assertTrue($result['enableRooms']);
         $this->assertFalse($result['enableBeta']);
 
         $user->created_at = Carbon::now()->subSeconds(181);
         $user->save();
 
         $result = UsersController::statusInfo($user);
 
         $this->assertSame('failed', $result['processState']);
 
         $user->status |= User::STATUS_LDAP_READY | User::STATUS_IMAP_READY;
         $user->save();
 
         $result = UsersController::statusInfo($user);
 
-        $this->assertTrue($result['isReady']);
-        if (\config('app.with_imap')) {
-            $this->assertCount(3, $result['process']);
-        } else {
-            $this->assertCount(2, $result['process']);
-        }
+        $this->assertTrue($result['isDone']);
+        $this->assertCount(3, $result['process']);
+        $this->assertSame('done', $result['processState']);
         $this->assertSame('user-new', $result['process'][0]['label']);
         $this->assertSame(true, $result['process'][0]['state']);
-        $this->assertSame('user-ldap-ready', $result['process'][1]['label']);
-        $this->assertSame(true, $result['process'][1]['state']);
-        if (\config('app.with_imap')) {
+        if (\config('app.with_ldap')) {
+            $this->assertSame('user-ldap-ready', $result['process'][1]['label']);
+            $this->assertSame(true, $result['process'][1]['state']);
             $this->assertSame('user-imap-ready', $result['process'][2]['label']);
             $this->assertSame(true, $result['process'][2]['state']);
+        } else {
+            $this->assertSame('user-imap-ready', $result['process'][1]['label']);
+            $this->assertSame(true, $result['process'][1]['state']);
         }
-        $this->assertSame('done', $result['processState']);
 
         $domain->status |= Domain::STATUS_VERIFIED;
         $domain->type = Domain::TYPE_EXTERNAL;
         $domain->save();
 
         $result = UsersController::statusInfo($user);
 
-        $this->assertFalse($result['isReady']);
+        $this->assertFalse($result['isDone']);
         $this->assertSame([], $result['skus']);
-
-        if (\config('app.with_imap')) {
-            $this->assertCount(7, $result['process']);
-            $this->assertSame('user-new', $result['process'][0]['label']);
-            $this->assertSame(true, $result['process'][0]['state']);
+        $this->assertCount(7, $result['process']);
+        $this->assertSame('user-new', $result['process'][0]['label']);
+        $this->assertSame(true, $result['process'][0]['state']);
+        if (\config('app.with_ldap')) {
             $this->assertSame('user-ldap-ready', $result['process'][1]['label']);
             $this->assertSame(true, $result['process'][1]['state']);
             $this->assertSame('user-imap-ready', $result['process'][2]['label']);
             $this->assertSame(true, $result['process'][2]['state']);
             $this->assertSame('domain-new', $result['process'][3]['label']);
             $this->assertSame(true, $result['process'][3]['state']);
             $this->assertSame('domain-ldap-ready', $result['process'][4]['label']);
             $this->assertSame(false, $result['process'][4]['state']);
             $this->assertSame('domain-verified', $result['process'][5]['label']);
             $this->assertSame(true, $result['process'][5]['state']);
             $this->assertSame('domain-confirmed', $result['process'][6]['label']);
             $this->assertSame(false, $result['process'][6]['state']);
         } else {
-            $this->assertCount(6, $result['process']);
-            $this->assertSame('user-new', $result['process'][0]['label']);
-            $this->assertSame(true, $result['process'][0]['state']);
-            $this->assertSame('user-ldap-ready', $result['process'][1]['label']);
+            $this->assertSame('user-imap-ready', $result['process'][1]['label']);
             $this->assertSame(true, $result['process'][1]['state']);
             $this->assertSame('domain-new', $result['process'][2]['label']);
             $this->assertSame(true, $result['process'][2]['state']);
-            $this->assertSame('domain-ldap-ready', $result['process'][3]['label']);
-            $this->assertSame(false, $result['process'][3]['state']);
-            $this->assertSame('domain-verified', $result['process'][4]['label']);
-            $this->assertSame(true, $result['process'][4]['state']);
-            $this->assertSame('domain-confirmed', $result['process'][5]['label']);
-            $this->assertSame(false, $result['process'][5]['state']);
+            $this->assertSame('domain-verified', $result['process'][3]['label']);
+            $this->assertSame(true, $result['process'][3]['state']);
+            $this->assertSame('domain-confirmed', $result['process'][4]['label']);
+            $this->assertSame(false, $result['process'][4]['state']);
         }
 
         // Test 'skus' property
         $user->assignSku(Sku::withEnvTenantContext()->where('title', 'beta')->first());
 
         $result = UsersController::statusInfo($user);
 
         $this->assertSame(['beta'], $result['skus']);
         $this->assertTrue($result['enableBeta']);
 
         $user->assignSku(Sku::withEnvTenantContext()->where('title', 'groupware')->first());
 
         $result = UsersController::statusInfo($user);
 
         $this->assertSame(['beta', 'groupware'], $result['skus']);
 
         // Degraded user
         $user->status |= User::STATUS_DEGRADED;
         $user->save();
 
         $result = UsersController::statusInfo($user);
         $this->assertTrue($result['enableBeta']);
         $this->assertFalse($result['enableRooms']);
 
         // User in a tenant without 'room' SKU
         $user->status = User::STATUS_LDAP_READY | User::STATUS_IMAP_READY | User::STATUS_ACTIVE;
         $user->tenant_id = Tenant::where('title', 'Sample Tenant')->first()->id;
         $user->save();
 
         $result = UsersController::statusInfo($user);
         $this->assertTrue($result['enableBeta']);
         $this->assertFalse($result['enableRooms']);
     }
 
     /**
      * Test user config update (POST /api/v4/users/<user>/config)
      */
     public function testSetConfig(): void
     {
         $jack = $this->getTestUser('jack@kolab.org');
         $john = $this->getTestUser('john@kolab.org');
 
         $john->setSetting('greylist_enabled', null);
         $john->setSetting('guam_enabled', null);
         $john->setSetting('password_policy', null);
         $john->setSetting('max_password_age', null);
 
         // Test unknown user id
         $post = ['greylist_enabled' => 1];
         $response = $this->actingAs($john)->post("/api/v4/users/123/config", $post);
         $json = $response->json();
 
         $response->assertStatus(404);
 
         // Test access by user not being a wallet controller
         $post = ['greylist_enabled' => 1];
         $response = $this->actingAs($jack)->post("/api/v4/users/{$john->id}/config", $post);
         $json = $response->json();
 
         $response->assertStatus(403);
 
         $this->assertSame('error', $json['status']);
         $this->assertSame("Access denied", $json['message']);
         $this->assertCount(2, $json);
 
         // Test some invalid data
         $post = ['grey' => 1, 'password_policy' => 'min:1,max:255'];
         $response = $this->actingAs($john)->post("/api/v4/users/{$john->id}/config", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(2, $json);
         $this->assertCount(2, $json['errors']);
         $this->assertSame("The requested configuration parameter is not supported.", $json['errors']['grey']);
         $this->assertSame("Minimum password length cannot be less than 6.", $json['errors']['password_policy']);
 
         $this->assertNull($john->fresh()->getSetting('greylist_enabled'));
 
         // Test some valid data
         $post = [
             'greylist_enabled' => 1,
             'guam_enabled' => 1,
             'password_policy' => 'min:10,max:255,upper,lower,digit,special',
             'max_password_age' => 6,
         ];
 
         $response = $this->actingAs($john)->post("/api/v4/users/{$john->id}/config", $post);
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertCount(2, $json);
         $this->assertSame('success', $json['status']);
         $this->assertSame('User settings updated successfully.', $json['message']);
 
         $this->assertSame('true', $john->getSetting('greylist_enabled'));
         $this->assertSame('true', $john->getSetting('guam_enabled'));
         $this->assertSame('min:10,max:255,upper,lower,digit,special', $john->getSetting('password_policy'));
         $this->assertSame('6', $john->getSetting('max_password_age'));
 
         // Test some valid data, acting as another account controller
         $ned = $this->getTestUser('ned@kolab.org');
         $post = ['greylist_enabled' => 0, 'guam_enabled' => 0, 'password_policy' => 'min:10,max:255,upper,last:1'];
         $response = $this->actingAs($ned)->post("/api/v4/users/{$john->id}/config", $post);
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertCount(2, $json);
         $this->assertSame('success', $json['status']);
         $this->assertSame('User settings updated successfully.', $json['message']);
 
         $this->assertSame('false', $john->fresh()->getSetting('greylist_enabled'));
         $this->assertSame(null, $john->fresh()->getSetting('guam_enabled'));
         $this->assertSame('min:10,max:255,upper,last:1', $john->fresh()->getSetting('password_policy'));
     }
 
     /**
      * Test user creation (POST /api/v4/users)
      */
     public function testStore(): void
     {
         Queue::fake();
 
         $jack = $this->getTestUser('jack@kolab.org');
         $john = $this->getTestUser('john@kolab.org');
         $john->setSetting('password_policy', 'min:8,max:100,digit');
         $deleted_priv = $this->getTestUser('deleted@kolab.org');
         $deleted_priv->delete();
 
         // Test empty request
         $response = $this->actingAs($john)->post("/api/v4/users", []);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertSame("The email field is required.", $json['errors']['email']);
         $this->assertSame("The password field is required.", $json['errors']['password'][0]);
         $this->assertCount(2, $json);
 
         // Test access by user not being a wallet controller
         $post = ['first_name' => 'Test'];
         $response = $this->actingAs($jack)->post("/api/v4/users", $post);
         $json = $response->json();
 
         $response->assertStatus(403);
 
         $this->assertSame('error', $json['status']);
         $this->assertSame("Access denied", $json['message']);
         $this->assertCount(2, $json);
 
         // Test some invalid data
         $post = ['password' => '12345678', 'email' => 'invalid'];
         $response = $this->actingAs($john)->post("/api/v4/users", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(2, $json);
         $this->assertSame('The password confirmation does not match.', $json['errors']['password'][0]);
         $this->assertSame('The specified email is invalid.', $json['errors']['email']);
 
         // Test existing user email
         $post = [
             'password' => 'simple123',
             'password_confirmation' => 'simple123',
             'first_name' => 'John2',
             'last_name' => 'Doe2',
             'email' => 'jack.daniels@kolab.org',
         ];
 
         $response = $this->actingAs($john)->post("/api/v4/users", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(2, $json);
         $this->assertSame('The specified email is not available.', $json['errors']['email']);
 
         $package_kolab = \App\Package::withEnvTenantContext()->where('title', 'kolab')->first();
         $package_domain = \App\Package::withEnvTenantContext()->where('title', 'domain-hosting')->first();
 
         $post = [
             'password' => 'simple123',
             'password_confirmation' => 'simple123',
             'first_name' => 'John2',
             'last_name' => 'Doe2',
             'email' => 'john2.doe2@kolab.org',
             'organization' => 'TestOrg',
             'aliases' => ['useralias1@kolab.org', 'deleted@kolab.org'],
         ];
 
         // Missing package
         $response = $this->actingAs($john)->post("/api/v4/users", $post);
         $json = $response->json();
 
         $response->assertStatus(422);
 
         $this->assertSame('error', $json['status']);
         $this->assertSame("Package is required.", $json['errors']['package']);
         $this->assertCount(2, $json);
 
         // Invalid package
         $post['package'] = $package_domain->id;
         $response = $this->actingAs($john)->post("/api/v4/users", $post);
         $json = $response->json();
 
         $response->assertStatus(422);
 
         $this->assertSame('error', $json['status']);
         $this->assertSame("Invalid package selected.", $json['errors']['package']);
         $this->assertCount(2, $json);
 
         // Test password policy checking
         $post['package'] = $package_kolab->id;
         $post['password'] = 'password';
         $response = $this->actingAs($john)->post("/api/v4/users", $post);
         $json = $response->json();
 
         $response->assertStatus(422);
 
         $this->assertSame('error', $json['status']);
         $this->assertSame("The password confirmation does not match.", $json['errors']['password'][0]);
         $this->assertSame("Specified password does not comply with the policy.", $json['errors']['password'][1]);
         $this->assertCount(2, $json);
 
         // Test password confirmation
         $post['password_confirmation'] = 'password';
         $response = $this->actingAs($john)->post("/api/v4/users", $post);
         $json = $response->json();
 
         $response->assertStatus(422);
 
         $this->assertSame('error', $json['status']);
         $this->assertSame("Specified password does not comply with the policy.", $json['errors']['password'][0]);
         $this->assertCount(2, $json);
 
         // Test full and valid data
         $post['password'] = 'password123';
         $post['password_confirmation'] = 'password123';
         $response = $this->actingAs($john)->post("/api/v4/users", $post);
         $json = $response->json();
 
         $response->assertStatus(200);
 
         $this->assertSame('success', $json['status']);
         $this->assertSame("User created successfully.", $json['message']);
         $this->assertCount(2, $json);
 
         $user = User::where('email', 'john2.doe2@kolab.org')->first();
         $this->assertInstanceOf(User::class, $user);
         $this->assertSame('John2', $user->getSetting('first_name'));
         $this->assertSame('Doe2', $user->getSetting('last_name'));
         $this->assertSame('TestOrg', $user->getSetting('organization'));
         /** @var \App\UserAlias[] $aliases */
         $aliases = $user->aliases()->orderBy('alias')->get();
         $this->assertCount(2, $aliases);
         $this->assertSame('deleted@kolab.org', $aliases[0]->alias);
         $this->assertSame('useralias1@kolab.org', $aliases[1]->alias);
         // Assert the new user entitlements
         $this->assertEntitlements($user, ['groupware', 'mailbox',
             'storage', 'storage', 'storage', 'storage', 'storage']);
         // Assert the wallet to which the new user should be assigned to
         $wallet = $user->wallet();
         $this->assertSame($john->wallets->first()->id, $wallet->id);
 
         // Attempt to create a user previously deleted
         $user->delete();
 
         $post['package'] = $package_kolab->id;
         $post['aliases'] = [];
         $response = $this->actingAs($john)->post("/api/v4/users", $post);
         $json = $response->json();
 
         $response->assertStatus(200);
 
         $this->assertSame('success', $json['status']);
         $this->assertSame("User created successfully.", $json['message']);
         $this->assertCount(2, $json);
 
         $user = User::where('email', 'john2.doe2@kolab.org')->first();
         $this->assertInstanceOf(User::class, $user);
         $this->assertSame('John2', $user->getSetting('first_name'));
         $this->assertSame('Doe2', $user->getSetting('last_name'));
         $this->assertSame('TestOrg', $user->getSetting('organization'));
         $this->assertCount(0, $user->aliases()->get());
         $this->assertEntitlements($user, ['groupware', 'mailbox',
             'storage', 'storage', 'storage', 'storage', 'storage']);
 
         // Test password reset link "mode"
         $code = new \App\VerificationCode(['mode' => 'password-reset', 'active' => false]);
         $john->verificationcodes()->save($code);
 
         $post = [
             'first_name' => 'John2',
             'last_name' => 'Doe2',
             'email' => 'deleted@kolab.org',
             'organization' => '',
             'aliases' => [],
             'passwordLinkCode' => $code->short_code . '-' . $code->code,
             'package' => $package_kolab->id,
         ];
 
         $response = $this->actingAs($john)->post("/api/v4/users", $post);
         $json = $response->json();
 
         $response->assertStatus(200);
 
         $this->assertSame('success', $json['status']);
         $this->assertSame("User created successfully.", $json['message']);
         $this->assertCount(2, $json);
 
         $user = $this->getTestUser('deleted@kolab.org');
         $code->refresh();
 
         $this->assertSame($user->id, $code->user_id);
         $this->assertTrue($code->active);
         $this->assertTrue(is_string($user->password) && strlen($user->password) >= 60);
 
         // Test acting as account controller not owner, which is not yet supported
         $john->wallets->first()->addController($user);
 
         $response = $this->actingAs($user)->post("/api/v4/users", []);
         $response->assertStatus(403);
     }
 
     /**
      * Test user update (PUT /api/v4/users/<user-id>)
      */
     public function testUpdate(): void
     {
         $userA = $this->getTestUser('UsersControllerTest1@userscontroller.com');
         $userA->setSetting('password_policy', 'min:8,digit');
         $jack = $this->getTestUser('jack@kolab.org');
         $john = $this->getTestUser('john@kolab.org');
         $ned = $this->getTestUser('ned@kolab.org');
         $domain = $this->getTestDomain(
             'userscontroller.com',
             ['status' => Domain::STATUS_NEW, 'type' => Domain::TYPE_EXTERNAL]
         );
 
         // Test unauthorized update of other user profile
         $response = $this->actingAs($jack)->get("/api/v4/users/{$userA->id}", []);
         $response->assertStatus(403);
 
         // Test authorized update of account owner by account controller
         $response = $this->actingAs($ned)->get("/api/v4/users/{$john->id}", []);
         $response->assertStatus(200);
 
         // Test updating of self (empty request)
         $response = $this->actingAs($userA)->put("/api/v4/users/{$userA->id}", []);
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame('success', $json['status']);
         $this->assertSame("User data updated successfully.", $json['message']);
         $this->assertTrue(!empty($json['statusInfo']));
         $this->assertCount(3, $json);
 
         // Test some invalid data
         $post = ['password' => '1234567', 'currency' => 'invalid'];
         $response = $this->actingAs($userA)->put("/api/v4/users/{$userA->id}", $post);
         $response->assertStatus(422);
 
         $json = $response->json();
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(2, $json);
         $this->assertSame("The password confirmation does not match.", $json['errors']['password'][0]);
         $this->assertSame("Specified password does not comply with the policy.", $json['errors']['password'][1]);
         $this->assertSame("The currency must be 3 characters.", $json['errors']['currency'][0]);
 
         // Test full profile update including password
         $post = [
             'password' => 'simple123',
             'password_confirmation' => 'simple123',
             'first_name' => 'John2',
             'last_name' => 'Doe2',
             'organization' => 'TestOrg',
             'phone' => '+123 123 123',
             'external_email' => 'external@gmail.com',
             'billing_address' => 'billing',
             'country' => 'CH',
             'currency' => 'CHF',
             'aliases' => ['useralias1@' . \config('app.domain'), 'useralias2@' . \config('app.domain')]
         ];
 
         $response = $this->actingAs($userA)->put("/api/v4/users/{$userA->id}", $post);
         $json = $response->json();
 
         $response->assertStatus(200);
 
         $this->assertSame('success', $json['status']);
         $this->assertSame("User data updated successfully.", $json['message']);
         $this->assertTrue(!empty($json['statusInfo']));
         $this->assertCount(3, $json);
         $this->assertTrue($userA->password != $userA->fresh()->password);
         unset($post['password'], $post['password_confirmation'], $post['aliases']);
         foreach ($post as $key => $value) {
             $this->assertSame($value, $userA->getSetting($key));
         }
         $aliases = $userA->aliases()->orderBy('alias')->get();
         $this->assertCount(2, $aliases);
         $this->assertSame('useralias1@' . \config('app.domain'), $aliases[0]->alias);
         $this->assertSame('useralias2@' . \config('app.domain'), $aliases[1]->alias);
 
         // Test unsetting values
         $post = [
             'first_name' => '',
             'last_name' => '',
             'organization' => '',
             'phone' => '',
             'external_email' => '',
             'billing_address' => '',
             'country' => '',
             'currency' => '',
             'aliases' => ['useralias2@' . \config('app.domain')]
         ];
 
         $response = $this->actingAs($userA)->put("/api/v4/users/{$userA->id}", $post);
         $json = $response->json();
 
         $response->assertStatus(200);
 
         $this->assertSame('success', $json['status']);
         $this->assertSame("User data updated successfully.", $json['message']);
         $this->assertTrue(!empty($json['statusInfo']));
         $this->assertCount(3, $json);
         unset($post['aliases']);
         foreach ($post as $key => $value) {
             $this->assertNull($userA->getSetting($key));
         }
         $aliases = $userA->aliases()->get();
         $this->assertCount(1, $aliases);
         $this->assertSame('useralias2@' . \config('app.domain'), $aliases[0]->alias);
 
         // Test error on some invalid aliases missing password confirmation
         $post = [
             'password' => 'simple123',
             'aliases' => [
                 'useralias2@' . \config('app.domain'),
                 'useralias1@kolab.org',
                 '@kolab.org',
             ]
         ];
 
         $response = $this->actingAs($userA)->put("/api/v4/users/{$userA->id}", $post);
         $json = $response->json();
 
         $response->assertStatus(422);
 
         $this->assertSame('error', $json['status']);
         $this->assertCount(2, $json['errors']);
         $this->assertCount(2, $json['errors']['aliases']);
         $this->assertSame("The specified domain is not available.", $json['errors']['aliases'][1]);
         $this->assertSame("The specified alias is invalid.", $json['errors']['aliases'][2]);
         $this->assertSame("The password confirmation does not match.", $json['errors']['password'][0]);
 
         // Test authorized update of other user
         $response = $this->actingAs($ned)->put("/api/v4/users/{$jack->id}", []);
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertTrue(empty($json['statusInfo']));
 
         // TODO: Test error on aliases with invalid/non-existing/other-user's domain
 
         // Create entitlements and additional user for following tests
         $owner = $this->getTestUser('UsersControllerTest1@userscontroller.com');
         $user = $this->getTestUser('UsersControllerTest2@userscontroller.com');
         $package_domain = Package::withEnvTenantContext()->where('title', 'domain-hosting')->first();
         $package_kolab = Package::withEnvTenantContext()->where('title', 'kolab')->first();
         $package_lite = Package::withEnvTenantContext()->where('title', 'lite')->first();
         $sku_mailbox = Sku::withEnvTenantContext()->where('title', 'mailbox')->first();
         $sku_storage = Sku::withEnvTenantContext()->where('title', 'storage')->first();
         $sku_groupware = Sku::withEnvTenantContext()->where('title', 'groupware')->first();
 
         $domain = $this->getTestDomain(
             'userscontroller.com',
             [
                 'status' => Domain::STATUS_NEW,
                 'type' => Domain::TYPE_EXTERNAL,
             ]
         );
 
         $domain->assignPackage($package_domain, $owner);
         $owner->assignPackage($package_kolab);
         $owner->assignPackage($package_lite, $user);
 
         // Non-controller cannot update his own entitlements
         $post = ['skus' => []];
         $response = $this->actingAs($user)->put("/api/v4/users/{$user->id}", $post);
         $response->assertStatus(422);
 
         // Test updating entitlements
         $post = [
             'skus' => [
                 $sku_mailbox->id => 1,
                 $sku_storage->id => 6,
                 $sku_groupware->id => 1,
             ],
         ];
 
         $response = $this->actingAs($owner)->put("/api/v4/users/{$user->id}", $post);
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $storage_cost = $user->entitlements()
             ->where('sku_id', $sku_storage->id)
             ->orderBy('cost')
             ->pluck('cost')->all();
 
         $this->assertEntitlements(
             $user,
             ['groupware', 'mailbox', 'storage', 'storage', 'storage', 'storage', 'storage', 'storage']
         );
 
         $this->assertSame([0, 0, 0, 0, 0, 25], $storage_cost);
         $this->assertTrue(empty($json['statusInfo']));
 
         // Test password reset link "mode"
         $code = new \App\VerificationCode(['mode' => 'password-reset', 'active' => false]);
         $owner->verificationcodes()->save($code);
 
         $post = ['passwordLinkCode' => $code->short_code . '-' . $code->code];
 
         $response = $this->actingAs($owner)->put("/api/v4/users/{$user->id}", $post);
         $json = $response->json();
 
         $response->assertStatus(200);
 
         $code->refresh();
 
         $this->assertSame($user->id, $code->user_id);
         $this->assertTrue($code->active);
         $this->assertSame($user->password, $user->fresh()->password);
     }
 
     /**
      * Test UsersController::updateEntitlements()
      */
     public function testUpdateEntitlements(): void
     {
         $jane = $this->getTestUser('jane@kolabnow.com');
 
         $kolab = Package::withEnvTenantContext()->where('title', 'kolab')->first();
         $storage = Sku::withEnvTenantContext()->where('title', 'storage')->first();
         $activesync = Sku::withEnvTenantContext()->where('title', 'activesync')->first();
         $groupware = Sku::withEnvTenantContext()->where('title', 'groupware')->first();
         $mailbox = Sku::withEnvTenantContext()->where('title', 'mailbox')->first();
 
         // standard package, 1 mailbox, 1 groupware, 2 storage
         $jane->assignPackage($kolab);
 
         // add 2 storage, 1 activesync
         $post = [
             'skus' => [
                 $mailbox->id => 1,
                 $groupware->id => 1,
                 $storage->id => 7,
                 $activesync->id => 1
             ]
         ];
 
         $response = $this->actingAs($jane)->put("/api/v4/users/{$jane->id}", $post);
         $response->assertStatus(200);
 
         $this->assertEntitlements(
             $jane,
             [
                 'activesync',
                 'groupware',
                 'mailbox',
                 'storage',
                 'storage',
                 'storage',
                 'storage',
                 'storage',
                 'storage',
                 'storage'
             ]
         );
 
         // add 2 storage, remove 1 activesync
         $post = [
             'skus' => [
                 $mailbox->id => 1,
                 $groupware->id => 1,
                 $storage->id => 9,
                 $activesync->id => 0
             ]
         ];
 
         $response = $this->actingAs($jane)->put("/api/v4/users/{$jane->id}", $post);
         $response->assertStatus(200);
 
         $this->assertEntitlements(
             $jane,
             [
                 'groupware',
                 'mailbox',
                 'storage',
                 'storage',
                 'storage',
                 'storage',
                 'storage',
                 'storage',
                 'storage',
                 'storage',
                 'storage'
             ]
         );
 
         // add mailbox
         $post = [
             'skus' => [
                 $mailbox->id => 2,
                 $groupware->id => 1,
                 $storage->id => 9,
                 $activesync->id => 0
             ]
         ];
 
         $response = $this->actingAs($jane)->put("/api/v4/users/{$jane->id}", $post);
         $response->assertStatus(500);
 
         $this->assertEntitlements(
             $jane,
             [
                 'groupware',
                 'mailbox',
                 'storage',
                 'storage',
                 'storage',
                 'storage',
                 'storage',
                 'storage',
                 'storage',
                 'storage',
                 'storage'
             ]
         );
 
         // remove mailbox
         $post = [
             'skus' => [
                 $mailbox->id => 0,
                 $groupware->id => 1,
                 $storage->id => 9,
                 $activesync->id => 0
             ]
         ];
 
         $response = $this->actingAs($jane)->put("/api/v4/users/{$jane->id}", $post);
         $response->assertStatus(500);
 
         $this->assertEntitlements(
             $jane,
             [
                 'groupware',
                 'mailbox',
                 'storage',
                 'storage',
                 'storage',
                 'storage',
                 'storage',
                 'storage',
                 'storage',
                 'storage',
                 'storage'
             ]
         );
 
         // less than free storage
         $post = [
             'skus' => [
                 $mailbox->id => 1,
                 $groupware->id => 1,
                 $storage->id => 1,
                 $activesync->id => 0
             ]
         ];
 
         $response = $this->actingAs($jane)->put("/api/v4/users/{$jane->id}", $post);
         $response->assertStatus(200);
 
         $this->assertEntitlements(
             $jane,
             [
                 'groupware',
                 'mailbox',
                 'storage',
                 'storage',
                 'storage',
                 'storage',
                 'storage'
             ]
         );
     }
 
     /**
      * Test user data response used in show and info actions
      */
     public function testUserResponse(): void
     {
         $provider = \config('services.payment_provider') ?: 'mollie';
         $user = $this->getTestUser('john@kolab.org');
         $wallet = $user->wallets()->first();
         $wallet->setSettings(['mollie_id' => null, 'stripe_id' => null]);
         $result = $this->invokeMethod(new UsersController(), 'userResponse', [$user]);
 
         $this->assertEquals($user->id, $result['id']);
         $this->assertEquals($user->email, $result['email']);
         $this->assertEquals($user->status, $result['status']);
         $this->assertTrue(is_array($result['statusInfo']));
 
         $this->assertTrue(is_array($result['settings']));
         $this->assertSame('US', $result['settings']['country']);
         $this->assertSame('USD', $result['settings']['currency']);
 
         $this->assertTrue(is_array($result['accounts']));
         $this->assertTrue(is_array($result['wallets']));
         $this->assertCount(0, $result['accounts']);
         $this->assertCount(1, $result['wallets']);
         $this->assertSame($wallet->id, $result['wallet']['id']);
         $this->assertArrayNotHasKey('discount', $result['wallet']);
 
         $this->assertTrue($result['statusInfo']['enableDomains']);
         $this->assertTrue($result['statusInfo']['enableWallets']);
         $this->assertTrue($result['statusInfo']['enableUsers']);
         $this->assertTrue($result['statusInfo']['enableSettings']);
 
         // Ned is John's wallet controller
         $ned = $this->getTestUser('ned@kolab.org');
         $ned_wallet = $ned->wallets()->first();
         $result = $this->invokeMethod(new UsersController(), 'userResponse', [$ned]);
 
         $this->assertEquals($ned->id, $result['id']);
         $this->assertEquals($ned->email, $result['email']);
         $this->assertTrue(is_array($result['accounts']));
         $this->assertTrue(is_array($result['wallets']));
         $this->assertCount(1, $result['accounts']);
         $this->assertCount(1, $result['wallets']);
         $this->assertSame($wallet->id, $result['wallet']['id']);
         $this->assertSame($wallet->id, $result['accounts'][0]['id']);
         $this->assertSame($ned_wallet->id, $result['wallets'][0]['id']);
         $this->assertSame($provider, $result['wallet']['provider']);
         $this->assertSame($provider, $result['wallets'][0]['provider']);
 
         $this->assertTrue($result['statusInfo']['enableDomains']);
         $this->assertTrue($result['statusInfo']['enableWallets']);
         $this->assertTrue($result['statusInfo']['enableUsers']);
         $this->assertTrue($result['statusInfo']['enableSettings']);
 
         // Test discount in a response
         $discount = Discount::where('code', 'TEST')->first();
         $wallet->discount()->associate($discount);
         $wallet->save();
         $mod_provider = $provider == 'mollie' ? 'stripe' : 'mollie';
         $wallet->setSetting($mod_provider . '_id', 123);
         $user->refresh();
 
         $result = $this->invokeMethod(new UsersController(), 'userResponse', [$user]);
 
         $this->assertEquals($user->id, $result['id']);
         $this->assertSame($discount->id, $result['wallet']['discount_id']);
         $this->assertSame($discount->discount, $result['wallet']['discount']);
         $this->assertSame($discount->description, $result['wallet']['discount_description']);
         $this->assertSame($mod_provider, $result['wallet']['provider']);
         $this->assertSame($discount->id, $result['wallets'][0]['discount_id']);
         $this->assertSame($discount->discount, $result['wallets'][0]['discount']);
         $this->assertSame($discount->description, $result['wallets'][0]['discount_description']);
         $this->assertSame($mod_provider, $result['wallets'][0]['provider']);
 
         // Jack is not a John's wallet controller
         $jack = $this->getTestUser('jack@kolab.org');
         $result = $this->invokeMethod(new UsersController(), 'userResponse', [$jack]);
 
         $this->assertFalse($result['statusInfo']['enableDomains']);
         $this->assertFalse($result['statusInfo']['enableWallets']);
         $this->assertFalse($result['statusInfo']['enableUsers']);
         $this->assertFalse($result['statusInfo']['enableSettings']);
     }
 
     /**
      * User email address validation.
      *
      * Note: Technically these include unit tests, but let's keep it here for now.
      * FIXME: Shall we do a http request for each case?
      */
     public function testValidateEmail(): void
     {
         Queue::fake();
 
         $public_domains = Domain::getPublicDomains();
         $domain = reset($public_domains);
 
         $john = $this->getTestUser('john@kolab.org');
         $jack = $this->getTestUser('jack@kolab.org');
         $user = $this->getTestUser('UsersControllerTest1@userscontroller.com');
         $folder = $this->getTestSharedFolder('folder-event@kolab.org');
         $folder->setAliases(['folder-alias1@kolab.org']);
         $folder_del = $this->getTestSharedFolder('folder-test@kolabnow.com');
         $folder_del->setAliases(['folder-alias2@kolabnow.com']);
         $folder_del->delete();
         $pub_group = $this->getTestGroup('group-test@kolabnow.com');
         $pub_group->delete();
         $priv_group = $this->getTestGroup('group-test@kolab.org');
         $resource = $this->getTestResource('resource-test@kolabnow.com');
         $resource->delete();
 
         $cases = [
             // valid (user domain)
             ["admin@kolab.org", $john, null],
 
             // valid (public domain)
             ["test.test@$domain", $john, null],
 
             // Invalid format
             ["$domain", $john, 'The specified email is invalid.'],
             [".@$domain", $john, 'The specified email is invalid.'],
             ["test123456@localhost", $john, 'The specified domain is invalid.'],
             ["test123456@unknown-domain.org", $john, 'The specified domain is invalid.'],
 
             ["$domain", $john, 'The specified email is invalid.'],
             [".@$domain", $john, 'The specified email is invalid.'],
 
             // forbidden local part on public domains
             ["admin@$domain", $john, 'The specified email is not available.'],
             ["administrator@$domain", $john, 'The specified email is not available.'],
 
             // forbidden (other user's domain)
             ["testtest@kolab.org", $user, 'The specified domain is not available.'],
 
             // existing alias of other user
             ["jack.daniels@kolab.org", $john, 'The specified email is not available.'],
 
             // An existing shared folder or folder alias
             ["folder-event@kolab.org", $john, 'The specified email is not available.'],
             ["folder-alias1@kolab.org", $john, 'The specified email is not available.'],
 
             // A soft-deleted shared folder or folder alias
             ["folder-test@kolabnow.com", $john, 'The specified email is not available.'],
             ["folder-alias2@kolabnow.com", $john, 'The specified email is not available.'],
 
             // A group
             ["group-test@kolab.org", $john, 'The specified email is not available.'],
 
             // A soft-deleted group
             ["group-test@kolabnow.com", $john, 'The specified email is not available.'],
 
             // A resource
             ["resource-test1@kolab.org", $john, 'The specified email is not available.'],
 
             // A soft-deleted resource
             ["resource-test@kolabnow.com", $john, 'The specified email is not available.'],
         ];
 
         foreach ($cases as $idx => $case) {
             list($email, $user, $expected) = $case;
 
             $deleted = null;
             $result = UsersController::validateEmail($email, $user, $deleted);
 
             $this->assertSame($expected, $result, "Case {$email}");
             $this->assertNull($deleted, "Case {$email}");
         }
     }
 
     /**
      * User email validation - tests for $deleted argument
      *
      * Note: Technically these include unit tests, but let's keep it here for now.
      * FIXME: Shall we do a http request for each case?
      */
     public function testValidateEmailDeleted(): void
     {
         Queue::fake();
 
         $john = $this->getTestUser('john@kolab.org');
         $deleted_priv = $this->getTestUser('deleted@kolab.org');
         $deleted_priv->delete();
         $deleted_pub = $this->getTestUser('deleted@kolabnow.com');
         $deleted_pub->delete();
 
         $result = UsersController::validateEmail('deleted@kolab.org', $john, $deleted);
         $this->assertSame(null, $result);
         $this->assertSame($deleted_priv->id, $deleted->id);
 
         $result = UsersController::validateEmail('deleted@kolabnow.com', $john, $deleted);
         $this->assertSame('The specified email is not available.', $result);
         $this->assertSame(null, $deleted);
 
         $result = UsersController::validateEmail('jack@kolab.org', $john, $deleted);
         $this->assertSame('The specified email is not available.', $result);
         $this->assertSame(null, $deleted);
 
         $pub_group = $this->getTestGroup('group-test@kolabnow.com');
         $priv_group = $this->getTestGroup('group-test@kolab.org');
 
         // A group in a public domain, existing
         $result = UsersController::validateEmail($pub_group->email, $john, $deleted);
         $this->assertSame('The specified email is not available.', $result);
         $this->assertNull($deleted);
 
         $pub_group->delete();
 
         // A group in a public domain, deleted
         $result = UsersController::validateEmail($pub_group->email, $john, $deleted);
         $this->assertSame('The specified email is not available.', $result);
         $this->assertNull($deleted);
 
         // A group in a private domain, existing
         $result = UsersController::validateEmail($priv_group->email, $john, $deleted);
         $this->assertSame('The specified email is not available.', $result);
         $this->assertNull($deleted);
 
         $priv_group->delete();
 
         // A group in a private domain, deleted
         $result = UsersController::validateEmail($priv_group->email, $john, $deleted);
         $this->assertSame(null, $result);
         $this->assertSame($priv_group->id, $deleted->id);
 
         // TODO: Test the same with a resource and shared folder
     }
 
     /**
      * User email alias validation.
      *
      * Note: Technically these include unit tests, but let's keep it here for now.
      * FIXME: Shall we do a http request for each case?
      */
     public function testValidateAlias(): void
     {
         Queue::fake();
 
         $public_domains = Domain::getPublicDomains();
         $domain = reset($public_domains);
 
         $john = $this->getTestUser('john@kolab.org');
         $user = $this->getTestUser('UsersControllerTest1@userscontroller.com');
         $deleted_priv = $this->getTestUser('deleted@kolab.org');
         $deleted_priv->setAliases(['deleted-alias@kolab.org']);
         $deleted_priv->delete();
         $deleted_pub = $this->getTestUser('deleted@kolabnow.com');
         $deleted_pub->setAliases(['deleted-alias@kolabnow.com']);
         $deleted_pub->delete();
         $folder = $this->getTestSharedFolder('folder-event@kolab.org');
         $folder->setAliases(['folder-alias1@kolab.org']);
         $folder_del = $this->getTestSharedFolder('folder-test@kolabnow.com');
         $folder_del->setAliases(['folder-alias2@kolabnow.com']);
         $folder_del->delete();
         $group_priv = $this->getTestGroup('group-test@kolab.org');
         $group = $this->getTestGroup('group-test@kolabnow.com');
         $group->delete();
         $resource = $this->getTestResource('resource-test@kolabnow.com');
         $resource->delete();
 
         $cases = [
             // Invalid format
             ["$domain", $john, 'The specified alias is invalid.'],
             [".@$domain", $john, 'The specified alias is invalid.'],
             ["test123456@localhost", $john, 'The specified domain is invalid.'],
             ["test123456@unknown-domain.org", $john, 'The specified domain is invalid.'],
 
             ["$domain", $john, 'The specified alias is invalid.'],
             [".@$domain", $john, 'The specified alias is invalid.'],
 
             // forbidden local part on public domains
             ["admin@$domain", $john, 'The specified alias is not available.'],
             ["administrator@$domain", $john, 'The specified alias is not available.'],
 
             // forbidden (other user's domain)
             ["testtest@kolab.org", $user, 'The specified domain is not available.'],
 
             // existing alias of other user, to be an alias, user in the same group account
             ["jack.daniels@kolab.org", $john, null],
 
             // existing user
             ["jack@kolab.org", $john, 'The specified alias is not available.'],
 
             // valid (user domain)
             ["admin@kolab.org", $john, null],
 
             // valid (public domain)
             ["test.test@$domain", $john, null],
 
             // An alias that was a user email before is allowed, but only for custom domains
             ["deleted@kolab.org", $john, null],
             ["deleted-alias@kolab.org", $john, null],
             ["deleted@kolabnow.com", $john, 'The specified alias is not available.'],
             ["deleted-alias@kolabnow.com", $john, 'The specified alias is not available.'],
 
             // An existing shared folder or folder alias
             ["folder-event@kolab.org", $john, 'The specified alias is not available.'],
             ["folder-alias1@kolab.org", $john, null],
 
             // A soft-deleted shared folder or folder alias
             ["folder-test@kolabnow.com", $john, 'The specified alias is not available.'],
             ["folder-alias2@kolabnow.com", $john, 'The specified alias is not available.'],
 
             // A group with the same email address exists
             ["group-test@kolab.org", $john, 'The specified alias is not available.'],
 
             // A soft-deleted group
             ["group-test@kolabnow.com", $john, 'The specified alias is not available.'],
 
             // A resource
             ["resource-test1@kolab.org", $john, 'The specified alias is not available.'],
 
             // A soft-deleted resource
             ["resource-test@kolabnow.com", $john, 'The specified alias is not available.'],
         ];
 
         foreach ($cases as $idx => $case) {
             list($alias, $user, $expected) = $case;
             $result = UsersController::validateAlias($alias, $user);
             $this->assertSame($expected, $result, "Case {$alias}");
         }
     }
 }
diff --git a/src/tests/Feature/Jobs/Resource/CreateTest.php b/src/tests/Feature/Jobs/Resource/CreateTest.php
index 3da1cd8b..12ff7fb1 100644
--- a/src/tests/Feature/Jobs/Resource/CreateTest.php
+++ b/src/tests/Feature/Jobs/Resource/CreateTest.php
@@ -1,89 +1,89 @@
 <?php
 
 namespace Tests\Feature\Jobs\Resource;
 
 use App\Resource;
 use Illuminate\Support\Facades\Queue;
 use Tests\TestCase;
 
 class CreateTest extends TestCase
 {
     /**
      * {@inheritDoc}
      */
     public function setUp(): void
     {
         parent::setUp();
 
         $this->deleteTestResource('resource-test@' . \config('app.domain'));
     }
 
     public function tearDown(): void
     {
         $this->deleteTestResource('resource-test@' . \config('app.domain'));
 
         parent::tearDown();
     }
 
     /**
      * Test job handle
      *
      * @group ldap
      * @group imap
      */
     public function testHandle(): void
     {
         Queue::fake();
 
         // Test unknown resource
         $this->expectException(\Exception::class);
         $job = new \App\Jobs\Resource\CreateJob(123);
         $job->handle();
 
         $this->assertTrue($job->isReleased());
         $this->assertFalse($job->hasFailed());
 
         $resource = $this->getTestResource(
             'resource-test@' . \config('app.domain'),
             ['status' => Resource::STATUS_NEW]
         );
 
         $this->assertFalse($resource->isLdapReady());
         $this->assertFalse($resource->isImapReady());
         $this->assertFalse($resource->isActive());
 
         // Test resource creation
         $job = new \App\Jobs\Resource\CreateJob($resource->id);
         $job->handle();
 
         $resource->refresh();
 
         $this->assertFalse($job->hasFailed());
-        $this->assertTrue($resource->isLdapReady());
+        $this->assertSame(\config('app.with_ldap'), $resource->isLdapReady());
         $this->assertTrue($resource->isImapReady());
         $this->assertTrue($resource->isActive());
 
         // Test job failures
         $resource->status |= Resource::STATUS_DELETED;
         $resource->save();
 
         $job = new \App\Jobs\Resource\CreateJob($resource->id);
         $job->handle();
 
         $this->assertTrue($job->hasFailed());
         $this->assertSame("Resource {$resource->id} is marked as deleted.", $job->failureMessage);
 
         $resource->status ^= Resource::STATUS_DELETED;
         $resource->save();
         $resource->delete();
 
         $job = new \App\Jobs\Resource\CreateJob($resource->id);
         $job->handle();
 
         $this->assertTrue($job->hasFailed());
         $this->assertSame("Resource {$resource->id} is actually deleted.", $job->failureMessage);
 
         // TODO: Test failures on domain sanity checks
         // TODO: Test partial execution, i.e. only IMAP or only LDAP
     }
 }
diff --git a/src/tests/Feature/Jobs/Resource/DeleteTest.php b/src/tests/Feature/Jobs/Resource/DeleteTest.php
index 4f88a862..7a7bea41 100644
--- a/src/tests/Feature/Jobs/Resource/DeleteTest.php
+++ b/src/tests/Feature/Jobs/Resource/DeleteTest.php
@@ -1,78 +1,76 @@
 <?php
 
 namespace Tests\Feature\Jobs\Resource;
 
 use App\Resource;
 use Illuminate\Support\Facades\Queue;
 use Tests\TestCase;
 
 class DeleteTest extends TestCase
 {
     /**
      * {@inheritDoc}
      */
     public function setUp(): void
     {
         parent::setUp();
 
         $this->deleteTestResource('resource-test@' . \config('app.domain'));
     }
 
     public function tearDown(): void
     {
         $this->deleteTestResource('resource-test@' . \config('app.domain'));
 
         parent::tearDown();
     }
 
     /**
      * Test job handle
      *
      * @group ldap
      * @group imap
      */
     public function testHandle(): void
     {
         Queue::fake();
 
         // Test non-existing resource ID
         $job = new \App\Jobs\Resource\DeleteJob(123);
         $job->handle();
 
         $this->assertTrue($job->hasFailed());
         $this->assertSame("Resource 123 could not be found in the database.", $job->failureMessage);
 
         $resource = $this->getTestResource('resource-test@' . \config('app.domain'), [
                 'status' => Resource::STATUS_NEW
         ]);
 
         // create the resource first
         $job = new \App\Jobs\Resource\CreateJob($resource->id);
         $job->handle();
 
         $resource->refresh();
 
-        $this->assertTrue($resource->isLdapReady());
-        if (\config('app.with_imap')) {
-            $this->assertTrue($resource->isImapReady());
-        }
+        $this->assertSame(\config('app.with_ldap'), $resource->isLdapReady());
+        $this->assertTrue($resource->isImapReady());
         $this->assertFalse($resource->isDeleted());
 
         // Test successful deletion
         $job = new \App\Jobs\Resource\DeleteJob($resource->id);
         $job->handle();
 
         $resource->refresh();
 
         $this->assertFalse($resource->isLdapReady());
         $this->assertFalse($resource->isImapReady());
         $this->assertTrue($resource->isDeleted());
 
         // Test deleting already deleted resource
         $job = new \App\Jobs\Resource\DeleteJob($resource->id);
         $job->handle();
 
         $this->assertTrue($job->hasFailed());
         $this->assertSame("Resource {$resource->id} is already marked as deleted.", $job->failureMessage);
     }
 }
diff --git a/src/tests/Feature/Jobs/SharedFolder/DeleteTest.php b/src/tests/Feature/Jobs/SharedFolder/DeleteTest.php
index 0a87b39e..8334e044 100644
--- a/src/tests/Feature/Jobs/SharedFolder/DeleteTest.php
+++ b/src/tests/Feature/Jobs/SharedFolder/DeleteTest.php
@@ -1,80 +1,80 @@
 <?php
 
 namespace Tests\Feature\Jobs\SharedFolder;
 
 use App\SharedFolder;
 use Illuminate\Support\Facades\Queue;
 use Tests\TestCase;
 
 class DeleteTest extends TestCase
 {
     /**
      * {@inheritDoc}
      */
     public function setUp(): void
     {
         parent::setUp();
 
         $this->deleteTestSharedFolder('folder-test@' . \config('app.domain'));
     }
 
     public function tearDown(): void
     {
         $this->deleteTestSharedFolder('folder-test@' . \config('app.domain'));
 
         parent::tearDown();
     }
 
     /**
      * Test job handle
      *
      * @group ldap
      * @group imap
      */
     public function testHandle(): void
     {
         Queue::fake();
 
         // Test non-existing folder ID
         $job = new \App\Jobs\SharedFolder\DeleteJob(123);
         $job->handle();
 
         $this->assertTrue($job->hasFailed());
         $this->assertSame("Shared folder 123 could not be found in the database.", $job->failureMessage);
 
         $folder = $this->getTestSharedFolder('folder-test@' . \config('app.domain'), [
                 'status' => SharedFolder::STATUS_NEW
         ]);
 
+        // Force with_imap=true, otherwise the folder creation job may fail
+        // TODO: Make the test working with various with_imap/with_ldap combinations
+        \config(['app.with_imap' => true]);
+
         // create the shared folder first
         $job = new \App\Jobs\SharedFolder\CreateJob($folder->id);
         $job->handle();
 
         $folder->refresh();
 
-        $this->assertTrue($folder->isLdapReady());
-        if (\config('app.with_imap')) {
-            $this->assertTrue($folder->isImapReady());
-        }
+        $this->assertSame(\config('app.with_ldap'), $folder->isLdapReady());
+        $this->assertTrue($folder->isImapReady());
         $this->assertFalse($folder->isDeleted());
 
         // Test successful deletion
         $job = new \App\Jobs\SharedFolder\DeleteJob($folder->id);
         $job->handle();
 
         $folder->refresh();
 
         $this->assertFalse($folder->isLdapReady());
-        if (\config('app.with_imap')) {
-            $this->assertFalse($folder->isImapReady());
-        }
+        $this->assertFalse($folder->isImapReady());
         $this->assertTrue($folder->isDeleted());
 
         // Test deleting already deleted folder
         $job = new \App\Jobs\SharedFolder\DeleteJob($folder->id);
         $job->handle();
 
         $this->assertTrue($job->hasFailed());
         $this->assertSame("Shared folder {$folder->id} is already marked as deleted.", $job->failureMessage);
     }
 }
diff --git a/src/tests/Feature/Jobs/SharedFolder/UpdateTest.php b/src/tests/Feature/Jobs/SharedFolder/UpdateTest.php
index 1d4c8b97..ea9af1ef 100644
--- a/src/tests/Feature/Jobs/SharedFolder/UpdateTest.php
+++ b/src/tests/Feature/Jobs/SharedFolder/UpdateTest.php
@@ -1,80 +1,82 @@
 <?php
 
 namespace Tests\Feature\Jobs\SharedFolder;
 
 use App\Backends\LDAP;
 use App\SharedFolder;
 use Illuminate\Support\Facades\Queue;
 use Tests\TestCase;
 
 class UpdateTest extends TestCase
 {
     /**
      * {@inheritDoc}
      */
     public function setUp(): void
     {
         parent::setUp();
 
         $this->deleteTestSharedFolder('folder-test@' . \config('app.domain'));
     }
 
     /**
      * {@inheritDoc}
      */
     public function tearDown(): void
     {
         $this->deleteTestSharedFolder('folder-test@' . \config('app.domain'));
 
         parent::tearDown();
     }
 
     /**
      * Test job handle
      *
      * @group ldap
      * @group imap
      */
     public function testHandle(): void
     {
         Queue::fake();
 
         // Test non-existing folder ID
         $job = new \App\Jobs\SharedFolder\UpdateJob(123);
         $job->handle();
 
         $this->assertTrue($job->hasFailed());
         $this->assertSame("Shared folder 123 could not be found in the database.", $job->failureMessage);
 
         $folder = $this->getTestSharedFolder(
             'folder-test@' . \config('app.domain'),
             ['status' => SharedFolder::STATUS_NEW]
         );
 
-        // Create the folder in LDAP
+        // Force with_imap=true, otherwise the folder creation job may fail
+        // TODO: Make the test working with various with_imap=false
+        \config(['app.with_imap' => true]);
+
+        // Create the folder in LDAP/IMAP
         $job = new \App\Jobs\SharedFolder\CreateJob($folder->id);
         $job->handle();
 
         $folder->refresh();
 
-        $this->assertTrue($folder->isLdapReady());
-        if (\config('app.with_imap')) {
-            $this->assertTrue($folder->isImapReady());
-        }
+        $this->assertSame(\config('app.with_ldap'), $folder->isLdapReady());
+        $this->assertTrue($folder->isImapReady());
 
         // Run the update job
         $job = new \App\Jobs\SharedFolder\UpdateJob($folder->id);
         $job->handle();
 
         // TODO: Assert that it worked on both LDAP and IMAP side
 
         // Test handling deleted folder
         $folder->status |= SharedFolder::STATUS_DELETED;
         $folder->save();
 
         $job = new \App\Jobs\SharedFolder\UpdateJob($folder->id);
         $job->handle();
 
         $this->assertTrue($job->isDeleted());
     }
 }
diff --git a/src/tests/Feature/Jobs/User/DeleteTest.php b/src/tests/Feature/Jobs/User/DeleteTest.php
index b4d2bcb8..ba780e76 100644
--- a/src/tests/Feature/Jobs/User/DeleteTest.php
+++ b/src/tests/Feature/Jobs/User/DeleteTest.php
@@ -1,100 +1,100 @@
 <?php
 
 namespace Tests\Feature\Jobs\User;
 
 use App\Backends\Roundcube;
 use App\User;
 use Illuminate\Support\Facades\Queue;
 use Tests\TestCase;
 
 class DeleteTest extends TestCase
 {
     /**
      * {@inheritDoc}
      */
     public function setUp(): void
     {
         parent::setUp();
 
         $this->deleteTestUser('new-job-user@' . \config('app.domain'));
     }
 
     /**
      * {@inheritDoc}
      */
     public function tearDown(): void
     {
         $this->deleteTestUser('new-job-user@' . \config('app.domain'));
 
         parent::tearDown();
     }
 
     /**
      * Test job handle
      *
      * @group ldap
      * @group imap
      * @group roundcube
      */
     public function testHandle(): void
     {
         Queue::fake();
 
         $rcdb = Roundcube::dbh();
 
         $user = $this->getTestUser('new-job-user@' . \config('app.domain'));
         $rcuser = Roundcube::userId($user->email);
 
         // Create the user in LDAP+IMAP
         $job = new \App\Jobs\User\CreateJob($user->id);
         $job->handle();
 
         $user->refresh();
 
-        $this->assertTrue($user->isLdapReady());
+        $this->assertSame(\config('app.with_ldap'), $user->isLdapReady());
         $this->assertTrue($user->isImapReady());
         $this->assertFalse($user->isDeleted());
         $this->assertNotNull($rcdb->table('users')->where('username', $user->email)->first());
 
         // Test job failure (user already deleted)
         $user->status |= User::STATUS_DELETED;
         $user->save();
 
         $job = new \App\Jobs\User\DeleteJob($user->id);
         $job->handle();
 
         $this->assertTrue($job->hasFailed());
         $this->assertSame("User {$user->id} is already marked as deleted.", $job->failureMessage);
 
         // Test success delete from LDAP, IMAP and Roundcube
         $user->status ^= User::STATUS_DELETED;
         $user->save();
 
         $this->assertFalse($user->isDeleted());
 
         $job = new \App\Jobs\User\DeleteJob($user->id);
         $job->handle();
 
         $user->refresh();
 
         $this->assertFalse($job->hasFailed());
         $this->assertFalse($user->isLdapReady());
         $this->assertFalse($user->isImapReady());
         $this->assertTrue($user->isDeleted());
         $this->assertNull($rcdb->table('users')->where('username', $user->email)->first());
 
         if (\config('app.with_imap')) {
             Queue::assertPushed(\App\Jobs\IMAP\AclCleanupJob::class, 1);
             Queue::assertPushed(
                 \App\Jobs\IMAP\AclCleanupJob::class,
                 function ($job) use ($user) {
                     $ident = TestCase::getObjectProperty($job, 'ident');
                     $domain = TestCase::getObjectProperty($job, 'domain');
                     return $ident == $user->email && $domain === '';
                 }
             );
         }
 
         // TODO: Test partial execution, i.e. only IMAP or only LDAP
     }
 }