diff --git a/config.demo/src/database/seeds/AppKeySeeder.php b/config.demo/src/database/seeds/AppKeySeeder.php
index 4554bf5..56063a9 100644
--- a/config.demo/src/database/seeds/AppKeySeeder.php
+++ b/config.demo/src/database/seeds/AppKeySeeder.php
@@ -1,62 +1,61 @@
 <?php
 
 namespace Database\Seeds;
 
 use Laravel\Passport\Passport;
 use Illuminate\Database\Seeder;
 use Illuminate\Encryption\Encrypter;
 
 class AppKeySeeder extends Seeder
 {
     /**
      * Run the database seeds.
      *
      * This emulates './artisan key:generate'
      *
      * @return void
      */
     public function run()
     {
         $key = $this->generateRandomKey();
         $this->writeNewEnvironmentFileWith($key);
     }
 
     /**
      * Generate a random key for the application.
      *
      * @return string
      */
     protected function generateRandomKey()
     {
         return 'base64:' . base64_encode(
             Encrypter::generateKey(\config('app.cipher'))
         );
     }
 
     /**
      * Write a new environment file with the given key.
      *
      * @param  string  $key
      * @return void
      */
     protected function writeNewEnvironmentFileWith($key)
     {
         file_put_contents(\app()->environmentFilePath(), preg_replace(
             $this->keyReplacementPattern(),
             'APP_KEY=' . $key,
             file_get_contents(\app()->environmentFilePath())
         ));
     }
 
     /**
      * Get a regex pattern that will match env APP_KEY with any random key.
      *
      * @return string
      */
     protected function keyReplacementPattern()
     {
         $escaped = preg_quote('=' . \config('app.key'), '/');
         return "/^APP_KEY{$escaped}/m";
     }
 }
-
diff --git a/config.demo/src/database/seeds/UserSeeder.php b/config.demo/src/database/seeds/UserSeeder.php
index 8812f91..bc378ae 100644
--- a/config.demo/src/database/seeds/UserSeeder.php
+++ b/config.demo/src/database/seeds/UserSeeder.php
@@ -1,250 +1,246 @@
 <?php
 
 namespace Database\Seeds;
 
 use App\Auth\SecondFactor;
 use App\Domain;
 use App\Entitlement;
 use App\User;
 use App\Sku;
 use Carbon\Carbon;
 use Illuminate\Database\Seeder;
 use App\Wallet;
 
 class UserSeeder extends Seeder
 {
     /**
      * Run the database seeds.
      *
      * @return void
      */
     public function run()
     {
         $domain = Domain::create(
             [
                 'namespace' => 'kolab.org',
                 'status' => Domain::STATUS_NEW
                     + Domain::STATUS_ACTIVE
                     + Domain::STATUS_CONFIRMED
                     + Domain::STATUS_VERIFIED,
                 'type' => Domain::TYPE_EXTERNAL
             ]
         );
 
         $john = User::create(
             [
                 'email' => 'john@kolab.org',
                 'password' => \App\Utils::generatePassphrase()
             ]
         );
 
         $john->setSettings(
             [
                 'first_name' => 'John',
                 'last_name' => 'Doe',
                 'currency' => 'USD',
                 'country' => 'US',
                 'billing_address' => "601 13th Street NW\nSuite 900 South\nWashington, DC 20005",
                 'external_email' => 'john.doe.external@gmail.com',
                 'organization' => 'Kolab Developers',
                 'phone' => '+1 509-248-1111',
             ]
         );
 
         $john->setAliases(['john.doe@kolab.org']);
 
         $wallet = $john->wallets->first();
 
         $packageDomain = \App\Package::withEnvTenantContext()->where('title', 'domain-hosting')->first();
         $packageKolab = \App\Package::withEnvTenantContext()->where('title', 'kolab')->first();
         $packageLite = \App\Package::withEnvTenantContext()->where('title', 'lite')->first();
 
         $domain->assignPackage($packageDomain, $john);
         $john->assignPackage($packageKolab);
 
 
         $appDomain = \App\Domain::where(
             [
                 'namespace' => \config('app.domain')
             ]
         )->first();
 
         $fred = User::create(
             [
                 'email' => 'fred@' . \config('app.domain'),
                 'password' => \App\Utils::generatePassphrase()
             ]
         );
 
         $fred->setSettings(
             [
                 'first_name' => 'fred',
                 'last_name' => 'Doe',
                 'currency' => 'USD',
                 'country' => 'US',
                 'billing_address' => "601 13th Street NW\nSuite 900 South\nWashington, DC 20005",
                 'external_email' => 'fred.doe.external@gmail.com',
                 'organization' => 'Kolab Developers',
                 'phone' => '+1 509-248-1111',
             ]
         );
 
         $appDomain->assignPackage($packageDomain, $fred);
         $fred->assignPackage($packageKolab);
 
 
         $jack = User::create(
             [
                 'email' => 'jack@kolab.org',
                 'password' => \App\Utils::generatePassphrase()
             ]
         );
 
         $jack->setSettings(
             [
                 'first_name' => 'Jack',
                 'last_name' => 'Daniels',
                 'currency' => 'USD',
                 'country' => 'US'
             ]
         );
 
         $jack->setAliases(['jack.daniels@kolab.org']);
 
         $john->assignPackage($packageKolab, $jack);
 
         foreach ($john->entitlements as $entitlement) {
             $entitlement->created_at = Carbon::now()->subMonthsWithoutOverflow(1);
             $entitlement->updated_at = Carbon::now()->subMonthsWithoutOverflow(1);
             $entitlement->save();
         }
 
         $ned = User::create(
             [
                 'email' => 'ned@kolab.org',
                 'password' => \App\Utils::generatePassphrase()
             ]
         );
 
         $ned->setSettings(
             [
                 'first_name' => 'Edward',
                 'last_name' => 'Flanders',
                 'currency' => 'USD',
                 'country' => 'US',
                 'guam_enabled' => false,
             ]
         );
 
         $john->assignPackage($packageKolab, $ned);
 
         $ned->assignSku(\App\Sku::withEnvTenantContext()->where('title', 'activesync')->first(), 1);
 
         // Ned is a controller on Jack's wallet
         $john->wallets()->first()->addController($ned);
 
         // Ned is also our 2FA test user
         $sku2fa = Sku::withEnvTenantContext()->where('title', '2fa')->first();
 
         $ned->assignSku($sku2fa);
 
         SecondFactor::seed('ned@kolab.org');
 
         $joe = User::create(
             [
                 'email' => 'joe@kolab.org',
                 'password' => \App\Utils::generatePassphrase()
             ]
         );
 
         $john->assignPackage($packageLite, $joe);
 
         //$john->assignSku(Sku::firstOrCreate(['title' => 'beta']));
         //$john->assignSku(Sku::firstOrCreate(['title' => 'meet']));
 
         $joe->setAliases(['joe.monster@kolab.org']);
 
         // This only exists so the user create job doesn't fail because the domain is not found
         Domain::create(
             [
                 'namespace' => 'jeroen.jeroen',
                 'status' => Domain::STATUS_NEW
                     + Domain::STATUS_ACTIVE
                     + Domain::STATUS_CONFIRMED
                     + Domain::STATUS_VERIFIED,
                 'type' => Domain::TYPE_EXTERNAL
             ]
         );
 
         $jeroen = User::create(
             [
                 'email' => 'jeroen@jeroen.jeroen',
                 'password' => \App\Utils::generatePassphrase()
             ]
         );
 
         $jeroen->role = 'admin';
         $jeroen->save();
 
         $reseller = User::create(
             [
                 'email' => 'reseller@' . \config('app.domain'),
                 'password' => \App\Utils::generatePassphrase()
             ]
         );
 
         $reseller->role = 'reseller';
         $reseller->save();
 
-        $reseller->assignPackage($packageKolab);
-
         // for tenants that are not the configured tenant id
         $tenants = \App\Tenant::where('id', '!=', \config('app.tenant_id'))->get();
 
         foreach ($tenants as $tenant) {
             $domain = Domain::where('tenant_id', $tenant->id)->first();
 
             $packageKolab = \App\Package::where(
                 [
                     'title' => 'kolab',
                     'tenant_id' => $tenant->id
                 ]
             )->first();
 
             if ($domain) {
                 $reseller = User::create(
                     [
                         'email' => 'reseller@' . $domain->namespace,
                         'password' => \App\Utils::generatePassphrase()
                     ]
                 );
 
                 $reseller->role = 'reseller';
                 $reseller->tenant_id = $tenant->id;
                 $reseller->save();
 
-                $reseller->assignPackage($packageKolab);
-
                 $user = User::create(
                     [
                         'email' => 'user@' . $domain->namespace,
                         'password' => \App\Utils::generatePassphrase()
                     ]
                 );
 
                 $user->tenant_id = $tenant->id;
                 $user->save();
 
                 $user->assignPackage($packageKolab);
             }
         }
 
         // Create imap admin service account
         User::create(
             [
                 'email' => \config('imap.admin_login'),
                 'password' => \config('imap.admin_password')
             ]
         );
     }
 }
diff --git a/src/tests/Feature/Console/Sku/ListUsersTest.php b/src/tests/Feature/Console/Sku/ListUsersTest.php
index be63457..cfbb9b9 100644
--- a/src/tests/Feature/Console/Sku/ListUsersTest.php
+++ b/src/tests/Feature/Console/Sku/ListUsersTest.php
@@ -1,72 +1,71 @@
 <?php
 
 namespace Tests\Feature\Console\Sku;
 
 use Illuminate\Contracts\Console\Kernel;
 use Tests\TestCase;
 
 class ListUsersTest extends TestCase
 {
     /**
      * {@inheritDoc}
      */
     public function setUp(): void
     {
         parent::setUp();
 
         $this->deleteTestUser('sku-list-users@kolabnow.com');
     }
 
     /**
      * {@inheritDoc}
      */
     public function tearDown(): void
     {
         $this->deleteTestUser('sku-list-users@kolabnow.com');
 
         parent::tearDown();
     }
 
     /**
      * Test command runs
      */
     public function testHandle(): void
     {
         // Warning: We're not using artisan() here, as this will not
         // allow us to test "empty output" cases
         $code = \Artisan::call('sku:list-users domain-registration');
         $output = trim(\Artisan::output());
         $this->assertSame(0, $code);
         $this->assertSame('', $output);
 
         $code = \Artisan::call('sku:list-users unknown');
         $output = trim(\Artisan::output());
         $this->assertSame(1, $code);
         $this->assertSame("Unable to find the SKU.", $output);
 
         $code = \Artisan::call('sku:list-users 2fa');
         $output = trim(\Artisan::output());
         $this->assertSame(0, $code);
         $this->assertSame("ned@kolab.org", $output);
 
         $code = \Artisan::call('sku:list-users mailbox');
         $output = trim(\Artisan::output());
         $this->assertSame(0, $code);
 
         $expected = [
             "fred@" . \config('app.domain'),
             "jack@kolab.org",
             "joe@kolab.org",
             "john@kolab.org",
             "ned@kolab.org",
-            "reseller@" . \config('app.domain')
         ];
 
         $this->assertSame(implode("\n", $expected), $output);
 
         $code = \Artisan::call('sku:list-users domain-hosting');
         $output = trim(\Artisan::output());
         $this->assertSame(0, $code);
         $this->assertSame("john@kolab.org", $output);
     }
 }
diff --git a/src/tests/Feature/Console/Wallet/TrialEndTest.php b/src/tests/Feature/Console/Wallet/TrialEndTest.php
index dbe1869..e1dba3e 100644
--- a/src/tests/Feature/Console/Wallet/TrialEndTest.php
+++ b/src/tests/Feature/Console/Wallet/TrialEndTest.php
@@ -1,116 +1,116 @@
 <?php
 
 namespace Tests\Feature\Console\Wallet;
 
 use App\User;
 use Illuminate\Support\Facades\DB;
 use Illuminate\Support\Facades\Queue;
 use Tests\TestCase;
 
 class TrialEndTest extends TestCase
 {
     /**
      * {@inheritDoc}
      */
     public function setUp(): void
     {
         parent::setUp();
 
         $this->deleteTestUser('test-user1@kolabnow.com');
-        $this->deleteTestUser('test-user22@kolabnow.com');
+        $this->deleteTestUser('test-user2@kolabnow.com');
     }
 
     /**
      * {@inheritDoc}
      */
     public function tearDown(): void
     {
         $this->deleteTestUser('test-user1@kolabnow.com');
-        $this->deleteTestUser('test-user22@kolabnow.com');
+        $this->deleteTestUser('test-user2@kolabnow.com');
 
         parent::tearDown();
     }
 
     /**
      * Test command run
      */
     public function testHandle(): void
     {
         Queue::fake();
 
         $plan = \App\Plan::withEnvTenantContext()->where('title', 'individual')->first();
         $user = $this->getTestUser('test-user1@kolabnow.com', [
                 'status' => User::STATUS_IMAP_READY | User::STATUS_LDAP_READY | User::STATUS_ACTIVE,
         ]);
         $wallet = $user->wallets()->first();
         $user->assignPlan($plan);
 
         DB::table('users')->update(['created_at' => \now()->clone()->subMonthsNoOverflow(2)->subHours(1)]);
 
         // No wallets in after-trial state, no email sent
         Queue::fake();
         $code = \Artisan::call("wallet:trial-end");
         Queue::assertNothingPushed();
 
         // Expect no email sent (out of time boundaries)
         $user->created_at = \now()->clone()->subMonthsNoOverflow(1)->addHour();
         $user->save();
 
         Queue::fake();
         $code = \Artisan::call("wallet:trial-end");
         Queue::assertNothingPushed();
 
         // Test an email sent
         $user->created_at = \now()->clone()->subMonthsNoOverflow(1);
         $user->save();
 
         Queue::fake();
         $code = \Artisan::call("wallet:trial-end");
         Queue::assertPushed(\App\Jobs\TrialEndEmail::class, 1);
         Queue::assertPushed(\App\Jobs\TrialEndEmail::class, function ($job) use ($user) {
             $job_user = TestCase::getObjectProperty($job, 'account');
             return $job_user->id === $user->id;
         });
 
         $dt = $wallet->getSetting('trial_end_notice');
         $this->assertMatchesRegularExpression('/^' . date('Y-m-d') . ' [0-9]{2}:[0-9]{2}:[0-9]{2}$/', $dt);
 
         // Test no duplicate email sent for the same wallet
         Queue::fake();
         $code = \Artisan::call("wallet:trial-end");
         Queue::assertNothingPushed();
 
         // Test not imap ready user - no email sent
         $wallet->setSetting('trial_end_notice', null);
         $user->status = User::STATUS_NEW | User::STATUS_LDAP_READY | User::STATUS_ACTIVE;
         $user->save();
 
         Queue::fake();
         $code = \Artisan::call("wallet:trial-end");
         Queue::assertNothingPushed();
 
         // Test deleted user - no email sent
         $user->status = User::STATUS_NEW | User::STATUS_LDAP_READY | User::STATUS_ACTIVE | User::STATUS_IMAP_READY;
         $user->save();
         $user->delete();
 
         Queue::fake();
         $code = \Artisan::call("wallet:trial-end");
         Queue::assertNothingPushed();
 
         $this->assertNull($wallet->getSetting('trial_end_notice'));
 
         // Make sure the non-controller users are omitted
         $user2 = $this->getTestUser('test-user2@kolabnow.com', [
                 'status' => User::STATUS_IMAP_READY | User::STATUS_LDAP_READY | User::STATUS_ACTIVE,
         ]);
         $package = \App\Package::withEnvTenantContext()->where('title', 'lite')->first();
         $user->assignPackage($package, $user2);
         $user2->created_at = \now()->clone()->subMonthsNoOverflow(1);
         $user2->save();
 
         Queue::fake();
         $code = \Artisan::call("wallet:trial-end");
         Queue::assertNothingPushed();
     }
 }
diff --git a/src/tests/Feature/Controller/Admin/StatsTest.php b/src/tests/Feature/Controller/Admin/StatsTest.php
index f7caf8c..26ebba4 100644
--- a/src/tests/Feature/Controller/Admin/StatsTest.php
+++ b/src/tests/Feature/Controller/Admin/StatsTest.php
@@ -1,252 +1,256 @@
 <?php
 
 namespace Tests\Feature\Controller\Admin;
 
 use App\Http\Controllers\API\V4\Admin\StatsController;
 use App\Payment;
 use App\Providers\PaymentProvider;
 use Illuminate\Support\Facades\DB;
 use Tests\TestCase;
 
 class StatsTest extends TestCase
 {
     /**
      * {@inheritDoc}
      */
     public function setUp(): void
     {
         parent::setUp();
         self::useAdminUrl();
 
         Payment::truncate();
         DB::table('wallets')->update(['discount_id' => null]);
+
+        $this->deleteTestUser('test-stats@' . \config('app.domain'));
     }
 
     /**
      * {@inheritDoc}
      */
     public function tearDown(): void
     {
         Payment::truncate();
         DB::table('wallets')->update(['discount_id' => null]);
 
+        $this->deleteTestUser('test-stats@' . \config('app.domain'));
+
         parent::tearDown();
     }
 
     /**
      * Test charts (GET /api/v4/stats/chart/<chart>)
      */
     public function testChart(): void
     {
         $user = $this->getTestUser('john@kolab.org');
         $admin = $this->getTestUser('jeroen@jeroen.jeroen');
 
         // Non-admin user
         $response = $this->actingAs($user)->get("api/v4/stats/chart/discounts");
         $response->assertStatus(403);
 
         // Unknown chart name
         $response = $this->actingAs($admin)->get("api/v4/stats/chart/unknown");
         $response->assertStatus(404);
 
         // 'discounts' chart
         $response = $this->actingAs($admin)->get("api/v4/stats/chart/discounts");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame('Discounts', $json['title']);
         $this->assertSame('donut', $json['type']);
         $this->assertSame([], $json['data']['labels']);
         $this->assertSame([['values' => []]], $json['data']['datasets']);
 
         // 'income' chart
         $response = $this->actingAs($admin)->get("api/v4/stats/chart/income");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame('Income in CHF - last 8 weeks', $json['title']);
         $this->assertSame('bar', $json['type']);
         $this->assertCount(8, $json['data']['labels']);
         $this->assertSame(date('Y-W'), $json['data']['labels'][7]);
         $this->assertSame([['values' => [0,0,0,0,0,0,0,0]]], $json['data']['datasets']);
 
         // 'users' chart
         $response = $this->actingAs($admin)->get("api/v4/stats/chart/users");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame('Users - last 8 weeks', $json['title']);
         $this->assertCount(8, $json['data']['labels']);
         $this->assertSame(date('Y-W'), $json['data']['labels'][7]);
         $this->assertCount(2, $json['data']['datasets']);
         $this->assertSame('Created', $json['data']['datasets'][0]['name']);
         $this->assertSame('Deleted', $json['data']['datasets'][1]['name']);
 
         // 'users-all' chart
         $response = $this->actingAs($admin)->get("api/v4/stats/chart/users-all");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame('All Users - last year', $json['title']);
         $this->assertCount(54, $json['data']['labels']);
         $this->assertCount(1, $json['data']['datasets']);
 
         // 'vouchers' chart
         $discount = \App\Discount::withObjectTenantContext($user)->where('code', 'TEST')->first();
         $wallet = $user->wallets->first();
         $wallet->discount()->associate($discount);
         $wallet->save();
 
         $response = $this->actingAs($admin)->get("api/v4/stats/chart/vouchers");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame('Vouchers', $json['title']);
         $this->assertSame(['TEST'], $json['data']['labels']);
         $this->assertSame([['values' => [1]]], $json['data']['datasets']);
     }
 
     /**
      * Test income chart currency handling
      */
     public function testChartIncomeCurrency(): void
     {
         $admin = $this->getTestUser('jeroen@jeroen.jeroen');
         $john = $this->getTestUser('john@kolab.org');
         $user = $this->getTestUser('test-stats@' . \config('app.domain'));
         $wallet = $user->wallets()->first();
         $wallet->currency = 'EUR';
         $wallet->save();
         $johns_wallet = $john->wallets()->first();
 
         // Create some test payments
         Payment::create([
                 'id' => 'test1',
                 'description' => '',
                 'status' => PaymentProvider::STATUS_PAID,
                 'amount' => 1000, // EUR
                 'type' => PaymentProvider::TYPE_ONEOFF,
                 'wallet_id' => $wallet->id,
                 'provider' => 'mollie',
                 'currency' => 'EUR',
                 'currency_amount' => 1000,
         ]);
         Payment::create([
                 'id' => 'test2',
                 'description' => '',
                 'status' => PaymentProvider::STATUS_PAID,
                 'amount' => 2000, // EUR
                 'type' => PaymentProvider::TYPE_RECURRING,
                 'wallet_id' => $wallet->id,
                 'provider' => 'mollie',
                 'currency' => 'EUR',
                 'currency_amount' => 2000,
         ]);
         Payment::create([
                 'id' => 'test3',
                 'description' => '',
                 'status' => PaymentProvider::STATUS_PAID,
                 'amount' => 3000, // CHF
                 'type' => PaymentProvider::TYPE_ONEOFF,
                 'wallet_id' => $johns_wallet->id,
                 'provider' => 'mollie',
                 'currency' => 'EUR',
                 'currency_amount' => 2800,
         ]);
         Payment::create([
                 'id' => 'test4',
                 'description' => '',
                 'status' => PaymentProvider::STATUS_PAID,
                 'amount' => 4000, // CHF
                 'type' => PaymentProvider::TYPE_RECURRING,
                 'wallet_id' => $johns_wallet->id,
                 'provider' => 'mollie',
                 'currency' => 'CHF',
                 'currency_amount' => 4000,
         ]);
         Payment::create([
                 'id' => 'test5',
                 'description' => '',
                 'status' => PaymentProvider::STATUS_OPEN,
                 'amount' => 5000, // CHF
                 'type' => PaymentProvider::TYPE_ONEOFF,
                 'wallet_id' => $johns_wallet->id,
                 'provider' => 'mollie',
                 'currency' => 'CHF',
                 'currency_amount' => 5000,
         ]);
         Payment::create([
                 'id' => 'test6',
                 'description' => '',
                 'status' => PaymentProvider::STATUS_FAILED,
                 'amount' => 6000, // CHF
                 'type' => PaymentProvider::TYPE_ONEOFF,
                 'wallet_id' => $johns_wallet->id,
                 'provider' => 'mollie',
                 'currency' => 'CHF',
                 'currency_amount' => 6000,
         ]);
 
         // 'income' chart
         $response = $this->actingAs($admin)->get("api/v4/stats/chart/income");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame('Income in CHF - last 8 weeks', $json['title']);
         $this->assertSame('bar', $json['type']);
         $this->assertCount(8, $json['data']['labels']);
         $this->assertSame(date('Y-W'), $json['data']['labels'][7]);
 
         // 7000 CHF + 3000 EUR =
         $expected = 7000 + intval(round(3000 * \App\Utils::exchangeRate('EUR', 'CHF')));
 
         $this->assertCount(1, $json['data']['datasets']);
         $this->assertSame($expected / 100, $json['data']['datasets'][0]['values'][7]);
     }
 
     /**
      * Test payers chart
      */
     public function testChartPayers(): void
     {
         $admin = $this->getTestUser('jeroen@jeroen.jeroen');
 
         DB::table('stats')->truncate();
 
         $response = $this->actingAs($admin)->get("api/v4/stats/chart/payers");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame('Payers - last year', $json['title']);
         $this->assertSame('line', $json['type']);
         $this->assertCount(54, $json['data']['labels']);
         $this->assertSame(date('Y-W'), $json['data']['labels'][53]);
         $this->assertCount(1, $json['data']['datasets']);
         $this->assertCount(54, $json['data']['datasets'][0]['values']);
 
         DB::table('stats')->insert([
                 'type' => StatsController::TYPE_PAYERS,
                 'value' => 5,
                 'created_at' => \now(),
         ]);
         DB::table('stats')->insert([
                 'type' => StatsController::TYPE_PAYERS,
                 'value' => 7,
                 'created_at' => \now(),
         ]);
 
         $response = $this->actingAs($admin)->get("api/v4/stats/chart/payers");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertSame(6, $json['data']['datasets'][0]['values'][53]);
     }
 }
diff --git a/src/tests/Feature/Controller/CompanionAppsTest.php b/src/tests/Feature/Controller/CompanionAppsTest.php
index e9b16e1..133fd66 100644
--- a/src/tests/Feature/Controller/CompanionAppsTest.php
+++ b/src/tests/Feature/Controller/CompanionAppsTest.php
@@ -1,324 +1,319 @@
 <?php
 
 namespace Tests\Feature\Controller;
 
 use App\User;
 use App\CompanionApp;
 use Laravel\Passport\Token;
 use Laravel\Passport\Passport;
 use Laravel\Passport\TokenRepository;
 use Tests\TestCase;
 
 class CompanionAppsTest extends TestCase
 {
     /**
      * {@inheritDoc}
      */
     public function setUp(): void
     {
         parent::setUp();
 
         $this->deleteTestUser('CompanionAppsTest1@userscontroller.com');
         $this->deleteTestUser('CompanionAppsTest2@userscontroller.com');
         $this->deleteTestCompanionApp('testdevice');
     }
 
     /**
      * {@inheritDoc}
      */
     public function tearDown(): void
     {
         $this->deleteTestUser('CompanionAppsTest1@userscontroller.com');
         $this->deleteTestUser('CompanionAppsTest2@userscontroller.com');
         $this->deleteTestCompanionApp('testdevice');
 
         parent::tearDown();
     }
 
     /**
      * Test creating the app
      */
     public function testStore(): void
     {
         $user = $this->getTestUser('CompanionAppsTest1@userscontroller.com');
 
         $name = "testname";
 
         $post = ['name' => $name];
         $response = $this->actingAs($user)->post("api/v4/companions", $post);
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertCount(3, $json);
         $this->assertSame('success', $json['status']);
         $this->assertSame("Companion app has been created.", $json['message']);
 
         $companionApp = \App\CompanionApp::where('name', $name)->first();
         $this->assertTrue($companionApp != null);
         $this->assertEquals($name, $companionApp->name);
         $this->assertFalse((bool)$companionApp->mfa_enabled);
     }
 
     /**
      * Test destroying the app
      */
     public function testDestroy(): void
     {
         $user = $this->getTestUser('CompanionAppsTest1@userscontroller.com');
         $user2 = $this->getTestUser('CompanionAppsTest2@userscontroller.com');
 
         $response = $this->actingAs($user)->delete("api/v4/companions/foobar");
         $response->assertStatus(404);
 
         $companionApp = $this->getTestCompanionApp(
             'testdevice',
             $user,
             [
                 'notification_token' => 'notificationtoken',
                 'mfa_enabled' => 1,
                 'name' => 'testname',
             ]
         );
 
         $client = Passport::client()->forceFill([
             'user_id' => $user->id,
             'name' => "CompanionApp Password Grant Client",
             'secret' => "VerySecret",
             'provider' => 'users',
             'redirect' => 'https://' . \config('app.website_domain'),
             'personal_access_client' => 0,
             'password_client' => 1,
             'revoked' => false,
             'allowed_scopes' => ["mfa"]
         ]);
-        print(var_export($client, true));
         $client->save();
         $companionApp->oauth_client_id = $client->id;
         $companionApp->save();
 
         $tokenRepository = app(TokenRepository::class);
         $tokenRepository->create([
             'id' => 'testtoken',
             'revoked' => false,
             'user_id' => $user->id,
             'client_id' => $client->id
         ]);
 
         //Make sure we have a token to revoke
         $tokenCount = Token::where('user_id', $user->id)->where('client_id', $client->id)->count();
         $this->assertTrue($tokenCount > 0);
 
 
         $response = $this->actingAs($user2)->delete("api/v4/companions/{$companionApp->id}");
         $response->assertStatus(403);
 
         $response = $this->actingAs($user)->delete("api/v4/companions/{$companionApp->id}");
         $response->assertStatus(200);
 
         $json = $response->json();
 
         $this->assertCount(2, $json);
         $this->assertSame('success', $json['status']);
         $this->assertSame("Companion app has been removed.", $json['message']);
 
         $client->refresh();
         $this->assertSame((bool)$client->revoked, true);
 
         $companionApp = \App\CompanionApp::where('device_id', 'testdevice')->first();
         $this->assertTrue($companionApp == null);
 
         $tokenCount = Token::where('user_id', $user->id)
             ->where('client_id', $client->id)
             ->where('revoked', false)->count();
         $this->assertSame(0, $tokenCount);
     }
 
-
     /**
      * Test listing apps
      */
     public function testIndex(): void
     {
         $response = $this->get("api/v4/companions");
         $response->assertStatus(401);
 
         $user = $this->getTestUser('CompanionAppsTest1@userscontroller.com');
 
         $companionApp = $this->getTestCompanionApp(
             'testdevice',
             $user,
             [
                 'notification_token' => 'notificationtoken',
                 'mfa_enabled' => 1,
                 'name' => 'testname',
             ]
         );
 
         $response = $this->actingAs($user)->get("api/v4/companions");
         $response->assertStatus(200);
 
         $json = $response->json();
         $this->assertSame(1, $json['count']);
         $this->assertCount(1, $json['list']);
         $this->assertSame($user->id, $json['list'][0]['user_id']);
         $this->assertSame($companionApp['device_id'], $json['list'][0]['device_id']);
         $this->assertSame($companionApp['name'], $json['list'][0]['name']);
         $this->assertSame($companionApp['notification_token'], $json['list'][0]['notification_token']);
         $this->assertSame($companionApp['mfa_enabled'], $json['list'][0]['mfa_enabled']);
 
         $user2 = $this->getTestUser('CompanionAppsTest2@userscontroller.com');
         $response = $this->actingAs($user2)->get(
             "api/v4/companions"
         );
         $response->assertStatus(200);
 
         $json = $response->json();
         $this->assertSame(0, $json['count']);
         $this->assertCount(0, $json['list']);
     }
 
-
     /**
      * Test showing the app
      */
     public function testShow(): void
     {
         $user = $this->getTestUser('CompanionAppsTest1@userscontroller.com');
         $companionApp = $this->getTestCompanionApp('testdevice', $user);
 
         $response = $this->get("api/v4/companions/{$companionApp->id}");
         $response->assertStatus(401);
 
         $response = $this->actingAs($user)->get("api/v4/companions/aaa");
         $response->assertStatus(404);
 
         $response = $this->actingAs($user)->get("api/v4/companions/{$companionApp->id}");
         $response->assertStatus(200);
 
         $json = $response->json();
         $this->assertSame($companionApp->id, $json['id']);
 
         $user2 = $this->getTestUser('CompanionAppsTest2@userscontroller.com');
         $response = $this->actingAs($user2)->get("api/v4/companions/{$companionApp->id}");
         $response->assertStatus(403);
     }
 
-
     /**
      * Test registering the app
      */
     public function testRegister(): void
     {
         $user = $this->getTestUser('CompanionAppsTest1@userscontroller.com');
 
         $companionApp = $this->getTestCompanionApp(
             'testdevice',
             $user,
             [
                 'notification_token' => 'notificationtoken',
                 'mfa_enabled' => 0,
                 'name' => 'testname',
             ]
         );
 
         $notificationToken = "notificationToken";
         $deviceId = "deviceId";
         $name = "testname";
 
         $response = $this->actingAs($user)->post(
             "api/v4/companion/register",
             [
                 'notificationToken' => $notificationToken,
                 'deviceId' => $deviceId,
                 'name' => $name,
                 'companionId' => $companionApp->id
             ]
         );
 
         $response->assertStatus(200);
 
         $companionApp->refresh();
         $this->assertTrue($companionApp != null);
         $this->assertEquals($deviceId, $companionApp->device_id);
         $this->assertEquals($name, $companionApp->name);
         $this->assertEquals($notificationToken, $companionApp->notification_token);
         $this->assertTrue((bool)$companionApp->mfa_enabled);
 
         // Companion id required
         $response = $this->actingAs($user)->post(
             "api/v4/companion/register",
             ['notificationToken' => $notificationToken, 'deviceId' => $deviceId, 'name' => $name]
         );
         $response->assertStatus(422);
 
         // Test a token update
         $notificationToken = "notificationToken2";
         $response = $this->actingAs($user)->post(
             "api/v4/companion/register",
             [
                 'notificationToken' => $notificationToken,
                 'deviceId' => $deviceId,
                 'name' => $name,
                 'companionId' => $companionApp->id
             ]
         );
 
         $response->assertStatus(200);
 
         $companionApp->refresh();
         $this->assertEquals($notificationToken, $companionApp->notification_token);
 
         // Failing input valdiation
         $response = $this->actingAs($user)->post(
             "api/v4/companion/register",
             []
         );
         $response->assertStatus(422);
 
         // Other users device
         $user2 = $this->getTestUser('CompanionAppsTest2@userscontroller.com');
         $response = $this->actingAs($user2)->post(
             "api/v4/companion/register",
             [
                 'notificationToken' => $notificationToken,
                 'deviceId' => $deviceId,
                 'name' => $name,
                 'companionId' => $companionApp->id
             ]
         );
         $response->assertStatus(403);
     }
 
-
     /**
      * Test getting the pairing info
      */
     public function testPairing(): void
     {
         $user = $this->getTestUser('CompanionAppsTest1@userscontroller.com');
 
         $companionApp = $this->getTestCompanionApp(
             'testdevice',
             $user,
             [
                 'notification_token' => 'notificationtoken',
                 'mfa_enabled' => 0,
                 'name' => 'testname',
             ]
         );
 
         $response = $this->get("api/v4/companions/{$companionApp->id}/pairing");
         $response->assertStatus(401);
 
         $response = $this->actingAs($user)->get("api/v4/companions/{$companionApp->id}/pairing");
         $response->assertStatus(200);
 
         $companionApp->refresh();
         $this->assertTrue($companionApp->oauth_client_id != null);
 
         $json = $response->json();
         $this->assertArrayHasKey('qrcode', $json);
         $this->assertSame('data:image/svg+xml;base64,', substr($json['qrcode'], 0, 26));
     }
 }
diff --git a/src/tests/Feature/Controller/UsersTest.php b/src/tests/Feature/Controller/UsersTest.php
index ff71999..9c74edc 100644
--- a/src/tests/Feature/Controller/UsersTest.php
+++ b/src/tests/Feature/Controller/UsersTest.php
@@ -1,1666 +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->status |= User::STATUS_IMAP_READY | User::STATUS_LDAP_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->status |= User::STATUS_IMAP_READY | User::STATUS_LDAP_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]);
         } 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);
         } 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']);
             $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('isLdapReady', $json);
             $this->assertSame('user-imap-ready', $json['process'][1]['label']);
             $this->assertFalse($json['process'][1]['state']);
         }
 
         // 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['isImapReady']);
         $this->assertFalse($json['isReady']);
         $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']);
         }
 
         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['isDone']);
         $this->assertSame([], $result['skus']);
         $this->assertCount(3, $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(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['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']);
         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']);
         }
 
         $domain->status |= Domain::STATUS_VERIFIED;
         $domain->type = Domain::TYPE_EXTERNAL;
         $domain->save();
 
         $result = UsersController::statusInfo($user);
 
         $this->assertFalse($result['isDone']);
         $this->assertSame([], $result['skus']);
         $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->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-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/SkuTest.php b/src/tests/Feature/SkuTest.php
index 05a85a2..e9fad72 100644
--- a/src/tests/Feature/SkuTest.php
+++ b/src/tests/Feature/SkuTest.php
@@ -1,109 +1,109 @@
 <?php
 
 namespace Tests\Feature;
 
 use App\Entitlement;
 use App\Handlers;
 use App\Package;
 use App\Sku;
 use Carbon\Carbon;
 use Tests\TestCase;
 
 class SkuTest extends TestCase
 {
     /**
      * {@inheritDoc}
      */
     public function setUp(): void
     {
         parent::setUp();
 
         $this->deleteTestUser('jane@kolabnow.com');
     }
 
     /**
      * {@inheritDoc}
      */
     public function tearDown(): void
     {
         $this->deleteTestUser('jane@kolabnow.com');
 
         parent::tearDown();
     }
 
     public function testPackageEntitlements(): void
     {
         $user = $this->getTestUser('jane@kolabnow.com');
 
         $wallet = $user->wallets()->first();
 
         $package = Package::withEnvTenantContext()->where('title', 'lite')->first();
 
         $user = $user->assignPackage($package);
 
         $this->backdateEntitlements($user->fresh()->entitlements, Carbon::now()->subMonthsWithoutOverflow(1));
 
         $wallet->chargeEntitlements();
 
         $this->assertTrue($wallet->balance < 0);
     }
 
     public function testSkuEntitlements(): void
     {
-        $this->assertCount(6, Sku::withEnvTenantContext()->where('title', 'mailbox')->first()->entitlements);
+        $this->assertCount(5, Sku::withEnvTenantContext()->where('title', 'mailbox')->first()->entitlements);
     }
 
     public function testSkuPackages(): void
     {
         $this->assertCount(2, Sku::withEnvTenantContext()->where('title', 'mailbox')->first()->packages);
     }
 
     public function testSkuHandlerDomainHosting(): void
     {
         $sku = Sku::withEnvTenantContext()->where('title', 'domain-hosting')->first();
 
         $entitlement = $sku->entitlements->first();
 
         $this->assertSame(
             Handlers\DomainHosting::entitleableClass(),
             $entitlement->entitleable_type
         );
     }
 
     public function testSkuHandlerMailbox(): void
     {
         $sku = Sku::withEnvTenantContext()->where('title', 'mailbox')->first();
 
         $entitlement = $sku->entitlements->first();
 
         $this->assertSame(
             Handlers\Mailbox::entitleableClass(),
             $entitlement->entitleable_type
         );
     }
 
     public function testSkuHandlerStorage(): void
     {
         $sku = Sku::withEnvTenantContext()->where('title', 'storage')->first();
 
         $entitlement = $sku->entitlements->first();
 
         $this->assertSame(
             Handlers\Storage::entitleableClass(),
             $entitlement->entitleable_type
         );
     }
 
     public function testSkuTenant(): void
     {
         $sku = Sku::withEnvTenantContext()->where('title', 'storage')->first();
 
         $tenant = $sku->tenant()->first();
 
         $this->assertInstanceof(\App\Tenant::class, $tenant);
 
         $tenant = $sku->tenant;
 
         $this->assertInstanceof(\App\Tenant::class, $tenant);
     }
 }