No OneTemporary
Actions

Size

52 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/src/tests/Browser/SignupTest.php b/src/tests/Browser/SignupTest.php
	index 0b4ad1c3..1aef39b9 100644
	--- a/src/tests/Browser/SignupTest.php
	+++ b/src/tests/Browser/SignupTest.php
	@@ -1,913 +1,910 @@
	<?php

	namespace Tests\Browser;

	use App\Discount;
	use App\Domain;
	use App\Plan;
	use App\SignupCode;
	use App\SignupInvitation;
	use App\User;
	use Tests\Browser;
	use Tests\Browser\Components\Menu;
	use Tests\Browser\Components\Toast;
	use Tests\Browser\Pages\Dashboard;
	use Tests\Browser\Pages\Home;
	use Tests\Browser\Pages\PaymentMollie;
	use Tests\Browser\Pages\PaymentStatus;
	use Tests\Browser\Pages\Signup;
	use Tests\TestCaseDusk;

	class SignupTest extends TestCaseDusk
	{
	/**
	* {@inheritDoc}
	*/
	public function setUp(): void
	{
	parent::setUp();

	$this->deleteTestUser('signuptestdusk@' . \config('app.domain'));
	$this->deleteTestUser('admin@user-domain-signup.com');
	$this->deleteTestDomain('user-domain-signup.com');

	Plan::whereNot('mode', Plan::MODE_EMAIL)->update(['mode' => Plan::MODE_EMAIL]);
	}

	/**
	* {@inheritDoc}
	*/
	public function tearDown(): void
	{
	$this->deleteTestUser('signuptestdusk@' . \config('app.domain'));
	$this->deleteTestUser('admin@user-domain-signup.com');
	$this->deleteTestDomain('user-domain-signup.com');
	SignupInvitation::truncate();

	Plan::whereNot('mode', Plan::MODE_EMAIL)->update(['mode' => Plan::MODE_EMAIL]);
	Discount::where('discount', 100)->update(['code' => null]);

	@unlink(storage_path('signup-tokens.txt'));

	parent::tearDown();
	}

	/**
	* Test signup code verification with a link
	*/
	public function testSignupCodeByLink(): void
	{
	// Test invalid code (invalid format)
	$this->browse(function (Browser $browser) {
	// Register Signup page element selectors we'll be using
	$browser->onWithoutAssert(new Signup());

	// TODO: Test what happens if user is logged in

	$browser->visit('/signup/invalid-code');

	// TODO: According to https://github.com/vuejs/vue-router/issues/977
	// it is not yet easily possible to display error page component (route)
	// without changing the URL
	// TODO: Instead of css selector we should probably define page/component
	// and use it instead
	$browser->waitFor('#error-page');
	});

	// Test invalid code (valid format)
	$this->browse(function (Browser $browser) {
	$browser->visit('/signup/XXXXX-code');

	// FIXME: User will not be able to continue anyway, so we should
	// either display 1st step or 404 error page
	$browser->waitFor('@step1')
	->assertToast(Toast::TYPE_ERROR, 'Form validation error');
	});

	// Test valid code
	$this->browse(function (Browser $browser) {
	$code = SignupCode::create([
	'email' => 'User@example.org',
	'first_name' => 'User',
	'last_name' => 'Name',
	'plan' => 'individual',
	'voucher' => '',
	]);

	$browser->visit('/signup/' . $code->short_code . '-' . $code->code)
	->waitFor('@step3')
	->assertMissing('@step1')
	->assertMissing('@step2');

	// FIXME: Find a nice way to read javascript data without using hidden inputs
	$this->assertSame($code->code, $browser->value('@step2 #signup_code'));

	// TODO: Test if the signup process can be completed
	});
	}

	/**
	* Test signup "welcome" page
	*/
	public function testSignupStep0(): void
	{
	$this->browse(function (Browser $browser) {
	$browser->visit(new Signup());

	$browser->assertVisible('@step0')
	->assertMissing('@step1')
	->assertMissing('@step2')
	->assertMissing('@step3');

	$browser->within(new Menu(), function ($browser) {
	$browser->assertMenuItems(['support', 'signup', 'login', 'lang'], 'signup');
	});

	$browser->waitFor('@step0 .plan-selector .card');

	// Assert first plan box and press the button
	$browser->with('@step0 .plan-selector .plan-individual', function ($step) {
	$step->assertVisible('button')
	->assertSeeIn('button', 'Individual Account')
	->assertVisible('.plan-description')
	->click('button');
	});

	$browser->waitForLocation('/signup/individual')
	->assertVisible('@step1')
	->assertSeeIn('.card-title', 'Sign Up - Step 1/3')
	->assertMissing('@step0')
	->assertMissing('@step2')
	->assertMissing('@step3')
	->assertFocused('@step1 #signup_first_name');

	// Click Back button
	$browser->click('@step1 [type=button]')
	->waitForLocation('/signup')
	->assertVisible('@step0')
	->assertMissing('@step1')
	->assertMissing('@step2')
	->assertMissing('@step3');

	// Choose the group account plan
	$browser->click('@step0 .plan-selector .plan-group button')
	->waitForLocation('/signup/group')
	->assertVisible('@step1')
	->assertMissing('@step0')
	->assertMissing('@step2')
	->assertMissing('@step3')
	->assertFocused('@step1 #signup_first_name');

	// TODO: Test if 'plan' variable is set properly in vue component
	});
	}

	/**
	* Test 1st step of the signup process
	*/
	public function testSignupStep1(): void
	{
	$this->browse(function (Browser $browser) {
	$browser->visit('/signup/individual')
	->onWithoutAssert(new Signup());

	// Here we expect two text inputs and Back and Continue buttons
	$browser->with('@step1', function ($step) {
	$step->waitFor('#signup_last_name')
	->assertSeeIn('.card-title', 'Sign Up - Step 1/3')
	->assertVisible('#signup_first_name')
	->assertFocused('#signup_first_name')
	->assertVisible('#signup_email')
	->assertVisible('[type=button]')
	->assertVisible('[type=submit]');
	});

	// Submit empty form
	// Email is required, so after pressing Submit
	// we expect focus to be moved to the email input
	$browser->with('@step1', function ($step) {
	$step->click('[type=submit]');
	$step->assertFocused('#signup_email');
	});

	$browser->within(new Menu(), function ($browser) {
	$browser->assertMenuItems(['support', 'signup', 'login', 'lang'], 'signup');
	});

	// Submit invalid email, and first_name
	// We expect both inputs to have is-invalid class added, with .invalid-feedback element
	$browser->with('@step1', function ($step) {
	$step->type('#signup_first_name', str_repeat('a', 250))
	->type('#signup_email', '@test')
	->click('[type=submit]')
	->waitFor('#signup_email.is-invalid')
	->assertVisible('#signup_first_name.is-invalid')
	->assertVisible('#signup_email + .invalid-feedback')
	->assertVisible('#signup_last_name + .invalid-feedback')
	->assertToast(Toast::TYPE_ERROR, 'Form validation error');
	});

	// Submit valid data
	// We expect error state on email input to be removed, and Step 2 form visible
	$browser->with('@step1', function ($step) {
	$step->type('#signup_first_name', 'Test')
	->type('#signup_last_name', 'User')
	->type('#signup_email', 'BrowserSignupTestUser1@kolab.org')
	->click('[type=submit]')
	->assertMissing('#signup_email.is-invalid')
	->assertMissing('#signup_email + .invalid-feedback');
	});

	$browser->waitUntilMissing('@step2 #signup_code[value=""]');
	$browser->waitFor('@step2');
	$browser->assertMissing('@step1');
	});
	}

	/**
	* Test 2nd Step of the signup process
	*
	* @depends testSignupStep1
	*/
	public function testSignupStep2(): void
	{
	$this->browse(function (Browser $browser) {
	$browser->assertVisible('@step2')
	->assertSeeIn('@step2 .card-title', 'Sign Up - Step 2/3')
	->assertMissing('@step0')
	->assertMissing('@step1')
	->assertMissing('@step3');

	// Here we expect one text input, Back and Continue buttons
	$browser->with('@step2', function ($step) {
	$step->assertVisible('#signup_short_code')
	->assertFocused('#signup_short_code')
	->assertVisible('[type=button]')
	->assertVisible('[type=submit]');
	});

	// Test Back button functionality
	$browser->click('@step2 [type=button]')
	->waitFor('@step1')
	->assertFocused('@step1 #signup_first_name')
	->assertMissing('@step2');

	// Submit valid Step 1 data (again)
	$browser->with('@step1', function ($step) {
	$step->type('#signup_first_name', 'User')
	->type('#signup_last_name', 'User')
	->type('#signup_email', 'BrowserSignupTestUser1@kolab.org')
	->click('[type=submit]');
	});

	$browser->waitFor('@step2');
	$browser->assertMissing('@step1');

	// Submit invalid code
	// We expect code input to have is-invalid class added, with .invalid-feedback element
	$browser->with('@step2', function ($step) {
	$step->type('#signup_short_code', 'XXXXX');
	$step->click('[type=submit]');

	$step->waitFor('#signup_short_code.is-invalid')
	->assertVisible('#signup_short_code + .invalid-feedback')
	->assertFocused('#signup_short_code')
	->assertToast(Toast::TYPE_ERROR, 'Form validation error');
	});

	// Submit valid code
	// We expect error state on code input to be removed, and Step 3 form visible
	$browser->with('@step2', function ($step) {
	// Get the code and short_code from database
	// FIXME: Find a nice way to read javascript data without using hidden inputs
	$code = $step->value('#signup_code');

	$this->assertNotEmpty($code);

	$code = SignupCode::find($code);

	$step->type('#signup_short_code', $code->short_code);
	$step->click('[type=submit]');

	$step->assertMissing('#signup_short_code.is-invalid');
	$step->assertMissing('#signup_short_code + .invalid-feedback');
	});

	$browser->waitFor('@step3');
	$browser->assertMissing('@step2');
	});
	}

	/**
	* Test 3rd Step of the signup process
	*
	* @depends testSignupStep2
	*/
	public function testSignupStep3(): void
	{
	$this->browse(function (Browser $browser) {
	$browser->assertVisible('@step3');

	// Here we expect 3 text inputs, Back and Continue buttons
	$browser->with('@step3', function ($step) {
	$domains = Domain::getPublicDomains();
	$domains_count = count($domains);

	$step->assertSeeIn('.card-title', 'Sign Up - Step 3/3')
	->assertMissing('#signup_last_name')
	->assertMissing('#signup_first_name')
	->assertVisible('#signup_login')
	->assertVisible('#signup_password')
	->assertVisible('#signup_password_confirmation')
	->assertVisible('select#signup_domain')
	->assertElementsCount('select#signup_domain option', $domains_count, false)
	->assertText('select#signup_domain option:nth-child(1)', $domains[0])
	->assertValue('select#signup_domain option:nth-child(1)', $domains[0])
	->assertText('select#signup_domain option:nth-child(2)', $domains[1])
	->assertValue('select#signup_domain option:nth-child(2)', $domains[1])
	->assertVisible('[type=button]')
	->assertVisible('[type=submit]')
	->assertSeeIn('[type=submit]', 'Submit')
	->assertFocused('#signup_login')
	->assertSelected('select#signup_domain', \config('app.domain'))
	->assertValue('#signup_login', '')
	->assertValue('#signup_password', '')
	->assertValue('#signup_password_confirmation', '')
	->with('#signup_password_policy', function (Browser $browser) {
	$browser->assertElementsCount('li', 2)
	->assertMissing('li:first-child svg.text-success')
	->assertSeeIn('li:first-child small', "Minimum password length: 6 characters")
	->assertMissing('li:last-child svg.text-success')
	->assertSeeIn('li:last-child small', "Maximum password length: 255 characters");
	});

	// TODO: Test domain selector
	});

	// Test Back button
	$browser->click('@step3 [type=button]');
	$browser->waitFor('@step2');
	$browser->assertFocused('@step2 #signup_short_code');
	$browser->assertMissing('@step3');

	// TODO: Test form reset when going back

	// Submit valid code again
	$browser->with('@step2', function ($step) {
	$code = $step->value('#signup_code');

	$this->assertNotEmpty($code);

	$code = SignupCode::find($code);

	$step->type('#signup_short_code', $code->short_code);
	$step->click('[type=submit]');
	});

	$browser->waitFor('@step3');

	// Submit invalid data
	$browser->with('@step3', function ($step) {
	$step->assertFocused('#signup_login')
	->type('#signup_login', '*')
	->type('#signup_password', '12345678')
	->type('#signup_password_confirmation', '123456789')
	->with('#signup_password_policy', function (Browser $browser) {
	$browser->waitFor('li:first-child svg.text-success')
	->waitFor('li:last-child svg.text-success');
	})
	->click('[type=submit]')
	->waitFor('#signup_login.is-invalid')
	->assertVisible('#signup_domain + .invalid-feedback')
	->assertVisible('#signup_password.is-invalid')
	->assertVisible('#signup_password_input .invalid-feedback')
	->assertFocused('#signup_login')
	->assertToast(Toast::TYPE_ERROR, 'Form validation error');
	});

	// Submit invalid data (valid login, invalid password)
	$browser->with('@step3', function ($step) {
	$step->type('#signup_login', 'SignupTestDusk')
	->click('[type=submit]')
	->waitFor('#signup_password.is-invalid')
	->assertVisible('#signup_password_input .invalid-feedback')
	->assertMissing('#signup_login.is-invalid')
	->assertMissing('#signup_domain + .invalid-feedback')
	->assertFocused('#signup_password')
	->assertToast(Toast::TYPE_ERROR, 'Form validation error');
	});

	// Submit valid data
	$browser->with('@step3', function ($step) {
	$step->type('#signup_password_confirmation', '12345678');

	$step->click('[type=submit]');
	});

	// At this point we should be auto-logged-in to dashboard
	$browser->waitUntilMissing('@step3')
	->waitUntilMissing('.app-loader')
	->on(new Dashboard())
	->assertUser('signuptestdusk@' . \config('app.domain'))
	->assertVisible('@links a.link-settings')
	->assertMissing('@links a.link-domains')
	->assertVisible('@links a.link-users')
	->assertVisible('@links a.link-wallet');

	// Logout the user
	$browser->within(new Menu(), function ($browser) {
	$browser->clickMenuItem('logout');
	});
	});
	}

	/**
	* Test signup for a group account
	*/
	public function testSignupGroup(): void
	{
	$this->browse(function (Browser $browser) {
	$browser->visit(new Signup());

	// Choose the group account plan
	$browser->waitFor('@step0 .plan-group button')
	->click('@step0 .plan-group button');

	// Submit valid data
	// We expect error state on email input to be removed, and Step 2 form visible
	$browser->whenAvailable('@step1', function ($step) {
	$step->type('#signup_first_name', 'Test')
	->type('#signup_last_name', 'User')
	->type('#signup_email', 'BrowserSignupTestUser1@kolab.org')
	->click('[type=submit]');
	});

	// Submit valid code
	$browser->whenAvailable('@step2', function ($step) {
	// Get the code and short_code from database
	// FIXME: Find a nice way to read javascript data without using hidden inputs
	$code = $step->value('#signup_code');
	$code = SignupCode::find($code);

	$step->type('#signup_short_code', $code->short_code)
	->click('[type=submit]');
	});

	// Here we expect 4 text inputs, Back and Continue buttons
	$browser->whenAvailable('@step3', function ($step) {
	$step->assertVisible('#signup_login')
	->assertVisible('#signup_password')
	->assertVisible('#signup_password_confirmation')
	->assertVisible('input#signup_domain')
	->assertVisible('[type=button]')
	->assertVisible('[type=submit]')
	->assertFocused('#signup_login')
	->assertValue('input#signup_domain', '')
	->assertValue('#signup_login', '')
	->assertValue('#signup_password', '')
	->assertValue('#signup_password_confirmation', '');
	});

	// Submit invalid login and password data
	$browser->with('@step3', function ($step) {
	$step->assertFocused('#signup_login')
	->type('#signup_login', '*')
	->type('#signup_domain', 'test.com')
	->type('#signup_password', '12345678')
	->type('#signup_password_confirmation', '123456789')
	->click('[type=submit]')
	->waitFor('#signup_login.is-invalid')
	->assertVisible('#signup_domain + .invalid-feedback')
	->assertVisible('#signup_password.is-invalid')
	->assertVisible('#signup_password_input .invalid-feedback')
	->assertFocused('#signup_login')
	->assertToast(Toast::TYPE_ERROR, 'Form validation error');
	});

	// Submit invalid domain
	$browser->with('@step3', function ($step) {
	$step->type('#signup_login', 'admin')
	->type('#signup_domain', 'aaa')
	->type('#signup_password', '12345678')
	->type('#signup_password_confirmation', '12345678')
	->click('[type=submit]')
	->waitUntilMissing('#signup_login.is-invalid')
	->waitFor('#signup_domain.is-invalid + .invalid-feedback')
	->assertMissing('#signup_password.is-invalid')
	->assertMissing('#signup_password_input .invalid-feedback')
	->assertFocused('#signup_domain')
	->assertToast(Toast::TYPE_ERROR, 'Form validation error');
	});

	// Submit invalid domain
	$browser->with('@step3', function ($step) {
	$step->type('#signup_domain', 'user-domain-signup.com')
	->click('[type=submit]');
	});

	// At this point we should be auto-logged-in to dashboard
	$browser->waitUntilMissing('@step3')
	->waitUntilMissing('.app-loader')
	->on(new Dashboard())
	->assertUser('admin@user-domain-signup.com')
	->assertVisible('@links a.link-settings')
	->assertVisible('@links a.link-domains')
	->assertVisible('@links a.link-users')
	->assertVisible('@links a.link-wallet');

	$browser->within(new Menu(), function ($browser) {
	$browser->clickMenuItem('logout');
	});
	});
	}

	/**
	* Test signup with a mandate plan, also the UI lock
	*
	* @group mollie
	*/
	public function testSignupMandate(): void
	{
	// Test the individual plan
	$plan = Plan::withEnvTenantContext()->where('title', 'individual')->first();
	$plan->mode = Plan::MODE_MANDATE;
	$plan->save();

	$this->browse(function (Browser $browser) {
	$browser->withConfig(['services.payment_provider' => 'mollie'])
	->visit(new Signup())
	->waitFor('@step0 .plan-individual button')
	->click('@step0 .plan-individual button')
	// Test Back button
	->whenAvailable('@step3', function ($browser) {
	$browser->click('button[type=button]');
	})
	->whenAvailable('@step0', function ($browser) {
	$browser->click('.plan-individual button');
	})
	// Test submit
	->whenAvailable('@step3', function ($browser) {
	$domains = Domain::getPublicDomains();
	$domains_count = count($domains);

	$browser->assertMissing('.card-title')
	->assertElementsCount('select#signup_domain option', $domains_count, false)
	->assertText('select#signup_domain option:nth-child(1)', $domains[0])
	->assertValue('select#signup_domain option:nth-child(1)', $domains[0])
	->type('#signup_login', 'signuptestdusk')
	->type('#signup_password', '12345678')
	->type('#signup_password_confirmation', '12345678')
	->click('[type=submit]');
	})
	->whenAvailable('@step4', function ($browser) {
	$browser->assertSeeIn('h4', 'The account is about to be created!')
	->assertSeeIn('h5', 'You are choosing a monthly subscription')
	->assertVisible('#summary-content')
	->assertElementsCount('#summary-content + p.credit-cards img', 2)
	->assertVisible('#summary-summary')
	->assertSeeIn('button.btn-primary', 'Subscribe')
	->assertSeeIn('button.btn-secondary', 'Back')
	->click('button.btn-secondary');
	})
	->whenAvailable('@step3', function ($browser) {
	$browser->assertValue('#signup_login', 'signuptestdusk')
	->click('[type=submit]');
	})
	->whenAvailable('@step4', function ($browser) {
	$browser->click('button.btn-primary');
	})
	->on(new PaymentMollie())
	->assertSeeIn('@title', 'Auto-Payment Setup')
	->assertMissing('@amount')
	->submitPayment('open')
	->on(new PaymentStatus())
	->assertSeeIn('@lock-alert', 'The account is locked')
	->assertSeeIn('@content', 'Checking the status...')
	->assertSeeIn('@button', 'Try again');
	});

	$user = User::where('email', 'signuptestdusk@' . \config('app.domain'))->first();
	$this->assertSame($plan->id, $user->getSetting('plan_id'));
	$this->assertFalse($user->isActive());

	// Refresh and see that the account is still locked
	$this->browse(function (Browser $browser) use ($user) {
	$browser->visit('/dashboard')
	->on(new PaymentStatus())
	->assertSeeIn('@lock-alert', 'The account is locked')
	->assertSeeIn('@content', 'Checking the status...');

	// Mark the payment paid, and activate the user in background,
	// expect unlock and redirect to the dashboard
	// TODO: Move this to a separate tests file for PaymentStatus page
	$payment = $user->wallets()->first()->payments()->first();
	$payment->credit('Test');
	$payment->status = \App\Payment::STATUS_PAID;
	$payment->save();
	$this->assertTrue($user->fresh()->isActive());

	$browser->waitForLocation('/dashboard', 10)
	->within(new Menu(), function ($browser) {
	$browser->clickMenuItem('logout');
	});
	});

	// TODO: Test the 'Try again' button on /payment/status page
	}

	/**
	* Test signup with a mandate plan with a discount=100%
	*/
	public function testSignupMandateDiscount100Percent(): void
	{
	// Test the individual plan
	$plan = Plan::withEnvTenantContext()->where('title', 'individual')->first();
	$plan->mode = Plan::MODE_MANDATE;
	$plan->save();

	$discount = Discount::where('discount', 100)->first();
	$discount->code = 'FREE';
	$discount->save();

	$this->browse(function (Browser $browser) {
	$browser->visit(new Signup())
	->waitFor('@step0 .plan-individual button')
	->click('@step0 .plan-individual button')
	- ->whenAvailable('@step0', function ($browser) {
	- $browser->click('.plan-individual button');
	- })
	->whenAvailable('@step3', function ($browser) {
	$browser->type('#signup_login', 'signuptestdusk')
	->type('#signup_password', '12345678')
	->type('#signup_password_confirmation', '12345678')
	->type('#signup_voucher', 'FREE')
	->click('[type=submit]');
	})
	->whenAvailable('@step4', function ($browser) {
	$browser->assertSeeIn('h4', 'The account is about to be created!')
	->assertSeeIn('#summary-content', 'You are signing up for an account with 100% discount.')
	->assertMissing('#summary-summary')
	->assertSeeIn('button.btn-primary', 'Subscribe')
	->assertSeeIn('button.btn-secondary', 'Back')
	->click('button.btn-primary');
	})
	->waitUntilMissing('@step4')
	->on(new Dashboard())
	->within(new Menu(), function ($browser) {
	$browser->clickMenuItem('logout');
	});
	});

	$user = User::where('email', 'signuptestdusk@' . \config('app.domain'))->first();

	$this->assertSame($plan->id, $user->getSetting('plan_id'));
	$this->assertTrue($user->isActive());
	$this->assertFalse($user->isRestricted());
	$this->assertSame($discount->id, $user->wallets->first()->discount_id);
	}

	/**
	* Test signup with a token plan
	*/
	public function testSignupToken(): void
	{
	// Test the individual plan
	Plan::where('title', 'individual')->update(['mode' => Plan::MODE_TOKEN]);

	// Register some valid tokens
	$tokens = ['1234567890', 'abcdefghijk'];
	file_put_contents(storage_path('signup-tokens.txt'), implode("\n", $tokens));

	$this->browse(function (Browser $browser) use ($tokens) {
	$browser->visit(new Signup())
	->waitFor('@step0 .plan-individual button')
	->click('@step0 .plan-individual button')
	// Step 1
	->whenAvailable('@step1', function ($browser) use ($tokens) {
	$browser->assertSeeIn('.card-title', 'Sign Up - Step 1/2')
	->type('#signup_first_name', 'Test')
	->type('#signup_last_name', 'User')
	->assertMissing('#signup_email')
	->type('#signup_token', '1234')
	// invalid token
	->click('[type=submit]')
	->waitFor('#signup_token.is-invalid')
	->assertVisible('#signup_token + .invalid-feedback')
	->assertFocused('#signup_token')
	->assertToast(Toast::TYPE_ERROR, 'Form validation error')
	// valid token
	->type('#signup_token', $tokens[0])
	->click('[type=submit]');
	})
	// Step 2
	->whenAvailable('@step3', function ($browser) {
	$domains = Domain::getPublicDomains();
	$domains_count = count($domains);

	$browser->assertSeeIn('.card-title', 'Sign Up - Step 2/2')
	->assertElementsCount('select#signup_domain option', $domains_count, false)
	->assertText('select#signup_domain option:nth-child(1)', $domains[0])
	->assertValue('select#signup_domain option:nth-child(1)', $domains[0])
	->type('#signup_login', 'signuptestdusk')
	->type('#signup_password', '12345678')
	->type('#signup_password_confirmation', '12345678')
	->click('[type=submit]');
	})
	->waitUntilMissing('@step3')
	->on(new Dashboard())
	->within(new Menu(), function ($browser) {
	$browser->clickMenuItem('logout');
	});
	});

	$user = User::where('email', 'signuptestdusk@' . \config('app.domain'))->first();
	$this->assertSame($tokens[0], $user->getSetting('signup_token'));
	$this->assertSame(null, $user->getSetting('external_email'));

	// Test the group plan
	Plan::where('title', 'group')->update(['mode' => Plan::MODE_TOKEN]);

	$this->browse(function (Browser $browser) use ($tokens) {
	$browser->visit(new Signup())
	->waitFor('@step0 .plan-group button')
	->click('@step0 .plan-group button')
	// Step 1
	->whenAvailable('@step1', function ($browser) use ($tokens) {
	$browser->assertSeeIn('.card-title', 'Sign Up - Step 1/2')
	->type('#signup_first_name', 'Test')
	->type('#signup_last_name', 'User')
	->assertMissing('#signup_email')
	->type('#signup_token', '1234')
	// invalid token
	->click('[type=submit]')
	->waitFor('#signup_token.is-invalid')
	->assertVisible('#signup_token + .invalid-feedback')
	->assertFocused('#signup_token')
	->assertToast(Toast::TYPE_ERROR, 'Form validation error')
	// valid token
	->type('#signup_token', $tokens[1])
	->click('[type=submit]');
	})
	// Step 2
	->whenAvailable('@step3', function ($browser) {
	$browser->assertSeeIn('.card-title', 'Sign Up - Step 2/2')
	->type('input#signup_domain', 'user-domain-signup.com')
	->type('#signup_login', 'admin')
	->type('#signup_password', '12345678')
	->type('#signup_password_confirmation', '12345678')
	->click('[type=submit]');
	})
	->waitUntilMissing('@step3')
	->on(new Dashboard())
	->within(new Menu(), function ($browser) {
	$browser->clickMenuItem('logout');
	});
	});

	$user = User::where('email', 'admin@user-domain-signup.com')->first();
	$this->assertSame($tokens[1], $user->getSetting('signup_token'));
	$this->assertSame(null, $user->getSetting('external_email'));
	}

	/**
	* Test signup with voucher
	*/
	public function testSignupVoucherLink(): void
	{
	$this->browse(function (Browser $browser) {
	$browser->visit('/signup/voucher/TEST')
	->onWithoutAssert(new Signup())
	->waitUntilMissing('.app-loader')
	->waitFor('@step0')
	->click('.plan-individual button')
	->whenAvailable('@step1', function (Browser $browser) {
	$browser->type('#signup_first_name', 'Test')
	->type('#signup_last_name', 'User')
	->type('#signup_email', 'BrowserSignupTestUser1@kolab.org')
	->click('[type=submit]');
	})
	->whenAvailable('@step2', function (Browser $browser) {
	// Get the code and short_code from database
	// FIXME: Find a nice way to read javascript data without using hidden inputs
	$code = $browser->value('#signup_code');

	$this->assertNotEmpty($code);

	$code = SignupCode::find($code);

	$browser->type('#signup_short_code', $code->short_code)
	->click('[type=submit]');
	})
	->whenAvailable('@step3', function (Browser $browser) {
	// Assert that the code is filled in the input
	// Change it and test error handling
	$browser->assertValue('#signup_voucher', 'TEST')
	->type('#signup_voucher', 'TESTXX')
	->type('#signup_login', 'signuptestdusk')
	->type('#signup_password', '123456789')
	->type('#signup_password_confirmation', '123456789')
	->click('[type=submit]')
	->waitFor('#signup_voucher.is-invalid')
	->assertVisible('#signup_voucher + .invalid-feedback')
	->assertFocused('#signup_voucher')
	->assertToast(Toast::TYPE_ERROR, 'Form validation error')
	// Submit the correct code
	->type('#signup_voucher', 'TEST')
	->click('[type=submit]');
	})
	->waitUntilMissing('@step3')
	->waitUntilMissing('.app-loader')
	->on(new Dashboard())
	->assertUser('signuptestdusk@' . \config('app.domain'))
	// Logout the user
	->within(new Menu(), function ($browser) {
	$browser->clickMenuItem('logout');
	});
	});

	$user = $this->getTestUser('signuptestdusk@' . \config('app.domain'));
	$discount = Discount::where('code', 'TEST')->first();
	$this->assertSame($discount->id, $user->wallets()->first()->discount_id);
	}

	/**
	* Test signup via invitation link
	*/
	public function testSignupInvitation(): void
	{
	// Test non-existing invitation
	$this->browse(function (Browser $browser) {
	$browser->visit('/signup/invite/TEST')
	->onWithoutAssert(new Signup())
	->waitFor('#app > #error-page')
	->assertErrorPage(404);
	});

	$invitation = SignupInvitation::create(['email' => 'test@domain.org']);

	$this->browse(function (Browser $browser) use ($invitation) {
	$browser->visit('/signup/invite/' . $invitation->id)
	->onWithoutAssert(new Signup())
	->waitUntilMissing('.app-loader')
	->with('@step3', function ($step) {
	$domains_count = count(Domain::getPublicDomains());

	$step->assertMissing('.card-title')
	->assertVisible('#signup_last_name')
	->assertVisible('#signup_first_name')
	->assertVisible('#signup_login')
	->assertVisible('#signup_password')
	->assertVisible('#signup_password_confirmation')
	->assertVisible('select#signup_domain')
	->assertElementsCount('select#signup_domain option', $domains_count, false)
	->assertVisible('[type=submit]')
	->assertMissing('[type=button]') // Back button
	->assertSeeIn('[type=submit]', 'Sign Up')
	->assertFocused('#signup_first_name')
	->assertValue('select#signup_domain', \config('app.domain'))
	->assertValue('#signup_first_name', '')
	->assertValue('#signup_last_name', '')
	->assertValue('#signup_login', '')
	->assertValue('#signup_password', '')
	->assertValue('#signup_password_confirmation', '');

	// Submit invalid data
	$step->type('#signup_login', '*')
	->type('#signup_password', '12345678')
	->type('#signup_password_confirmation', '123456789')
	->click('[type=submit]')
	->waitFor('#signup_login.is-invalid')
	->assertVisible('#signup_domain + .invalid-feedback')
	->assertVisible('#signup_password.is-invalid')
	->assertVisible('#signup_password_input .invalid-feedback')
	->assertFocused('#signup_login')
	->assertToast(Toast::TYPE_ERROR, 'Form validation error');

	// Submit valid data
	$step->type('#signup_password_confirmation', '12345678')
	->type('#signup_login', 'signuptestdusk')
	->type('#signup_first_name', 'First')
	->type('#signup_last_name', 'Last')
	->click('[type=submit]');
	})
	// At this point we should be auto-logged-in to dashboard
	->waitUntilMissing('@step3')
	->waitUntilMissing('.app-loader')
	->on(new Dashboard())
	->assertUser('signuptestdusk@' . \config('app.domain'))
	// Logout the user
	->within(new Menu(), function ($browser) {
	$browser->clickMenuItem('logout');
	});
	});

	$invitation->refresh();
	$user = User::where('email', 'signuptestdusk@' . \config('app.domain'))->first();

	$this->assertTrue($invitation->isCompleted());
	$this->assertSame($user->id, $invitation->user_id);
	$this->assertSame('First', $user->getSetting('first_name'));
	$this->assertSame('Last', $user->getSetting('last_name'));
	$this->assertSame($invitation->email, $user->getSetting('external_email'));
	}
	}
	diff --git a/src/tests/Browser/StatusTest.php b/src/tests/Browser/StatusTest.php
	index 23e096a2..233ca00c 100644
	--- a/src/tests/Browser/StatusTest.php
	+++ b/src/tests/Browser/StatusTest.php
	@@ -1,287 +1,287 @@
	<?php

	namespace Tests\Browser;

	use App\Domain;
	use App\User;
	use Carbon\Carbon;
	use Tests\Browser;
	use Tests\Browser\Components\Status;
	use Tests\Browser\Components\Toast;
	use Tests\Browser\Pages\Dashboard;
	use Tests\Browser\Pages\DomainInfo;
	use Tests\Browser\Pages\DomainList;
	use Tests\Browser\Pages\Home;
	use Tests\Browser\Pages\UserInfo;
	use Tests\Browser\Pages\UserList;
	use Tests\TestCaseDusk;
	use Illuminate\Support\Facades\DB;

	class StatusTest extends TestCaseDusk
	{
	/**
	* {@inheritDoc}
	*/
	public function setUp(): void
	{
	parent::setUp();

	$domain_status = Domain::STATUS_CONFIRMED \| Domain::STATUS_VERIFIED;
	DB::statement("UPDATE domains SET status = (status \| {$domain_status})"
	. " WHERE namespace = 'kolab.org'");
	DB::statement("UPDATE users SET status = (status \| " . (User::STATUS_IMAP_READY \| User::STATUS_LDAP_READY) . ")"
	. " WHERE email = 'john@kolab.org'");
	}

	/**
	* {@inheritDoc}
	*/
	public function tearDown(): void
	{
	$domain_status = Domain::STATUS_CONFIRMED \| Domain::STATUS_VERIFIED;
	DB::statement("UPDATE domains SET status = (status \| {$domain_status})"
	. " WHERE namespace = 'kolab.org'");
	DB::statement("UPDATE users SET status = (status \| " . User::STATUS_IMAP_READY . ")"
	. " WHERE email = 'john@kolab.org'");

	parent::tearDown();
	}

	/**
	* Test account status in the Dashboard
	*/
	public function testDashboard(): void
	{
	// Unconfirmed domain and user
	$domain = Domain::where('namespace', 'kolab.org')->first();

	if ($domain->isConfirmed()) {
	$domain->status ^= Domain::STATUS_CONFIRMED;
	$domain->save();
	}

	$john = $this->getTestUser('john@kolab.org');

	$john->created_at = Carbon::now();

	if ($john->isImapReady()) {
	$john->status ^= User::STATUS_IMAP_READY;
	}

	$john->save();

	$this->browse(function ($browser) use ($john, $domain) {
	$browser->visit(new Home())
	->submitLogon('john@kolab.org', 'simple123', true)
	->on(new Dashboard())
	->with(new Status(), function ($browser) use ($john) {
	$browser->assertSeeIn('@body', 'We are preparing your account')
	->assertProgress(71, 'Creating a mailbox...', 'pending')
	->assertMissing('#status-verify')
	->assertMissing('#status-link')
	->assertMissing('@refresh-button')
	->assertMissing('@refresh-text');

	$john->status \|= User::STATUS_IMAP_READY;
	$john->save();

	// Wait for auto-refresh, expect domain-confirmed step
	$browser->pause(6000)
	->assertSeeIn('@body', 'Your account is almost ready')
	->assertProgress(85, 'Verifying an ownership of a custom domain...', 'failed')
	->assertMissing('@refresh-button')
	->assertMissing('@refresh-text')
	->assertMissing('#status-verify')
	->assertVisible('#status-link');
	})
	// check if the link to domain info page works
	->click('#status-link')
	->on(new DomainInfo())
	->back()
	->on(new Dashboard())
	->with(new Status(), function ($browser) {
	$browser->assertMissing('@refresh-button')
	->assertProgress(85, 'Verifying an ownership of a custom domain...', 'failed');
	});

	// Confirm the domain and wait until the whole status box disappears
	$domain->status \|= Domain::STATUS_CONFIRMED;
	$domain->save();

	// This should take less than 10 seconds
	$browser->waitUntilMissing('@status', 10);
	});

	// Test the Refresh button
	if ($domain->isConfirmed()) {
	$domain->status ^= Domain::STATUS_CONFIRMED;
	$domain->save();
	}

	$john->created_at = Carbon::now()->subSeconds(3600);

	if ($john->isImapReady()) {
	$john->status ^= User::STATUS_IMAP_READY;
	}

	$john->save();

	$this->browse(function ($browser) use ($john, $domain) {
	$browser->visit(new Dashboard())
	->with(new Status(), function ($browser) use ($john, $domain) {
	$browser->assertSeeIn('@body', 'We are preparing your account')
	->assertProgress(71, 'Creating a mailbox...', 'failed')
	->assertVisible('@refresh-button')
	->assertVisible('@refresh-text');

	$browser->click('@refresh-button')
	->assertToast(Toast::TYPE_SUCCESS, 'Setup process has been pushed. Please wait.');

	$john->status \|= User::STATUS_IMAP_READY;
	$john->save();
	$domain->status \|= Domain::STATUS_CONFIRMED;
	$domain->save();
	})
	->waitUntilMissing('@status', 10);
	});
	}

	/**
	* Test domain status on domains list and domain info page
	*
	* @depends testDashboard
	*/
	public function testDomainStatus(): void
	{
	$domain = Domain::where('namespace', 'kolab.org')->first();
	$domain->created_at = Carbon::now();
	$domain->status = Domain::STATUS_NEW \| Domain::STATUS_ACTIVE \| Domain::STATUS_LDAP_READY;
	$domain->save();

	// side-step
	$this->assertFalse($domain->isNew());
	$this->assertTrue($domain->isActive());
	$this->assertTrue($domain->isLdapReady());
	$this->assertTrue($domain->isExternal());

	$this->assertFalse($domain->isHosted());
	$this->assertFalse($domain->isConfirmed());
	$this->assertFalse($domain->isVerified());
	$this->assertFalse($domain->isSuspended());
	$this->assertFalse($domain->isDeleted());

	$this->browse(function ($browser) use ($domain) {
	// Test auto-refresh
	$browser->on(new Dashboard())
	->click('@links a.link-domains')
	->on(new DomainList())
	->waitFor('@table tbody tr')
	// Assert domain status icon
	->assertVisible('@table tbody tr:first-child td:first-child svg.fa-globe.text-danger')
	->assertText('@table tbody tr:first-child td:first-child svg title', 'Not Ready')
	->click('@table tbody tr:first-child td:first-child a')
	->on(new DomainInfo())
	->with(new Status(), function ($browser) {
	$browser->assertSeeIn('@body', 'We are preparing the domain')
	->assertProgress(50, 'Verifying a custom domain...', 'pending')
	->assertMissing('@refresh-button')
	->assertMissing('@refresh-text')
	->assertMissing('#status-link')
	->assertMissing('#status-verify');
	});

	$domain->status \|= Domain::STATUS_VERIFIED;
	$domain->save();

	// This should take less than 10 seconds
	$browser->waitFor('@status.process-failed')
	->with(new Status(), function ($browser) {
	$browser->assertSeeIn('@body', 'The domain is almost ready')
	->assertProgress(75, 'Verifying an ownership of a custom domain...', 'failed')
	->assertMissing('@refresh-button')
	->assertMissing('@refresh-text')
	->assertMissing('#status-link')
	->assertVisible('#status-verify');
	});

	$domain->status \|= Domain::STATUS_CONFIRMED;
	$domain->save();

	// Test Verify button
	$browser->click('@status #status-verify')
	->assertToast(Toast::TYPE_SUCCESS, 'Domain verified successfully.')
	->waitUntilMissing('@status')
	->waitUntilMissing('@verify')
	->assertVisible('@config');
	});
	}

	/**
	* Test user status on users list and user info page
	*
	* @depends testDashboard
	*/
	public function testUserStatus(): void
	{
	$john = $this->getTestUser('john@kolab.org');
	$john->created_at = Carbon::now();
	if ($john->isImapReady()) {
	$john->status ^= User::STATUS_IMAP_READY;
	}
	$john->save();

	$domain = Domain::where('namespace', 'kolab.org')->first();
	if ($domain->isConfirmed()) {
	$domain->status ^= Domain::STATUS_CONFIRMED;
	$domain->save();
	}

	$this->browse(function ($browser) use ($john, $domain) {
	$browser->visit(new Dashboard())
	->click('@links a.link-users')
	->on(new UserList())
	->waitFor('@table tbody tr')
	// Assert user status icons
	->assertVisible('@table tbody tr:first-child td:first-child svg.fa-user.text-success')
	->assertText('@table tbody tr:first-child td:first-child svg title', 'Active')
	->assertVisible('@table tbody tr:nth-child(3) td:first-child svg.fa-user.text-danger')
	->assertText('@table tbody tr:nth-child(3) td:first-child svg title', 'Not Ready')
	->click('@table tbody tr:nth-child(3) td:first-child a')
	->on(new UserInfo())
	- ->with('@form', function (Browser $browser) {
	+ ->with('@general', function (Browser $browser) {
	// Assert state in the user edit form
	$browser->assertSeeIn('div.row:nth-child(1) label', 'Status')
	->assertSeeIn('div.row:nth-child(1) #status', 'Not Ready');
	})
	->with(new Status(), function ($browser) use ($john) {
	$browser->assertSeeIn('@body', 'We are preparing the user account')
	->assertProgress(71, 'Creating a mailbox...', 'pending')
	->assertMissing('#status-verify')
	->assertMissing('#status-link')
	->assertMissing('@refresh-button')
	->assertMissing('@refresh-text');


	$john->status \|= User::STATUS_IMAP_READY;
	$john->save();

	// Wait for auto-refresh, expect domain-confirmed step
	$browser->pause(6000)
	->assertSeeIn('@body', 'The user account is almost ready')
	->assertProgress(85, 'Verifying an ownership of a custom domain...', 'failed')
	->assertMissing('@refresh-button')
	->assertMissing('@refresh-text')
	->assertMissing('#status-verify')
	->assertVisible('#status-link');
	})
	->assertSeeIn('#status', 'Active');

	// Confirm the domain and wait until the whole status box disappears
	$domain->status \|= Domain::STATUS_CONFIRMED;
	$domain->save();

	// This should take less than 10 seconds
	$browser->waitUntilMissing('@status', 10);
	});
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Sat, Mar 1, 4:15 AM (1 d, 5 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 165786
Default Alt Text: (52 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions