Removed unused tests

Added README
2026-03-21 10:11:56 +01:00 · 2026-03-21 10:10:22 +01:00
12 changed files with 42 additions and 736 deletions
--- a/README.md
+++ b/README.md
@@ -0,0 +1,42 @@
 # Perceptron and neuronal networks
 Using Laravel and Vue JS
 ## Installation
 1. Install PHP, Composer and NodeJs
    - With Herd
      <https://herd.laravel.com/windows>
    - Using a single command from the [Laravel installation page](https://laravel.com/docs/12.x/installation)
    ```powershell
    # Run as administrator...
    Set-ExecutionPolicy Bypass -Scope Process -Force; [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol -bor 3072; iex ((New-Object System.Net.WebClient).DownloadString('https://php.new/install/windows/8.4'))
    ```
    - Manually :
        1. PHP
           <https://www.php.net/downloads.php>
        2. Composer
           <https://getcomposer.org/download/>
        3. NodeJs (Node + NPM)
           <https://nodejs.org/en/download>
 2. Install dependencies
 ```shell
 composer install
 ```
 ## Running the project
 There is a script inside `composer.json` that will launch each part of the application in parallel.
 To run this script :
 ```shell
 composer run dev
 ```
 And go with your favorite browser to <http://127.0.0.1:8000/>
--- a/tests/Feature/Auth/AuthenticationTest.php
+++ b/tests/Feature/Auth/AuthenticationTest.php
@@ -1,99 +0,0 @@
 <?php
 namespace Tests\Feature\Auth;
 use App\Models\User;
 use Illuminate\Foundation\Testing\RefreshDatabase;
 use Illuminate\Support\Facades\RateLimiter;
 use Laravel\Fortify\Features;
 use Tests\TestCase;
 class AuthenticationTest extends TestCase
 {
    use RefreshDatabase;
    public function test_login_screen_can_be_rendered()
    {
        $response = $this->get(route('login'));
        $response->assertOk();
    }
    public function test_users_can_authenticate_using_the_login_screen()
    {
        $user = User::factory()->create();
        $response = $this->post(route('login.store'), [
            'email' => $user->email,
            'password' => 'password',
        ]);
        $this->assertAuthenticated();
        $response->assertRedirect(route('dashboard', absolute: false));
    }
    public function test_users_with_two_factor_enabled_are_redirected_to_two_factor_challenge()
    {
        if (! Features::canManageTwoFactorAuthentication()) {
            $this->markTestSkipped('Two-factor authentication is not enabled.');
        }
        Features::twoFactorAuthentication([
            'confirm' => true,
            'confirmPassword' => true,
        ]);
        $user = User::factory()->create();
        $user->forceFill([
            'two_factor_secret' => encrypt('test-secret'),
            'two_factor_recovery_codes' => encrypt(json_encode(['code1', 'code2'])),
            'two_factor_confirmed_at' => now(),
        ])->save();
        $response = $this->post(route('login'), [
            'email' => $user->email,
            'password' => 'password',
        ]);
        $response->assertRedirect(route('two-factor.login'));
        $response->assertSessionHas('login.id', $user->id);
        $this->assertGuest();
    }
    public function test_users_can_not_authenticate_with_invalid_password()
    {
        $user = User::factory()->create();
        $this->post(route('login.store'), [
            'email' => $user->email,
            'password' => 'wrong-password',
        ]);
        $this->assertGuest();
    }
    public function test_users_can_logout()
    {
        $user = User::factory()->create();
        $response = $this->actingAs($user)->post(route('logout'));
        $this->assertGuest();
        $response->assertRedirect(route('home'));
    }
    public function test_users_are_rate_limited()
    {
        $user = User::factory()->create();
        RateLimiter::increment(md5('login'.implode('|', [$user->email, '127.0.0.1'])), amount: 5);
        $response = $this->post(route('login.store'), [
            'email' => $user->email,
            'password' => 'wrong-password',
        ]);
        $response->assertTooManyRequests();
    }
 }
--- a/tests/Feature/Auth/EmailVerificationTest.php
+++ b/tests/Feature/Auth/EmailVerificationTest.php
@@ -1,110 +0,0 @@
 <?php
 namespace Tests\Feature\Auth;
 use App\Models\User;
 use Illuminate\Auth\Events\Verified;
 use Illuminate\Foundation\Testing\RefreshDatabase;
 use Illuminate\Support\Facades\Event;
 use Illuminate\Support\Facades\URL;
 use Tests\TestCase;
 class EmailVerificationTest extends TestCase
 {
    use RefreshDatabase;
    public function test_email_verification_screen_can_be_rendered()
    {
        $user = User::factory()->unverified()->create();
        $response = $this->actingAs($user)->get(route('verification.notice'));
        $response->assertOk();
    }
    public function test_email_can_be_verified()
    {
        $user = User::factory()->unverified()->create();
        Event::fake();
        $verificationUrl = URL::temporarySignedRoute(
            'verification.verify',
            now()->addMinutes(60),
            ['id' => $user->id, 'hash' => sha1($user->email)],
        );
        $response = $this->actingAs($user)->get($verificationUrl);
        Event::assertDispatched(Verified::class);
        $this->assertTrue($user->fresh()->hasVerifiedEmail());
        $response->assertRedirect(route('dashboard', absolute: false).'?verified=1');
    }
    public function test_email_is_not_verified_with_invalid_hash()
    {
        $user = User::factory()->unverified()->create();
        Event::fake();
        $verificationUrl = URL::temporarySignedRoute(
            'verification.verify',
            now()->addMinutes(60),
            ['id' => $user->id, 'hash' => sha1('wrong-email')],
        );
        $this->actingAs($user)->get($verificationUrl);
        Event::assertNotDispatched(Verified::class);
        $this->assertFalse($user->fresh()->hasVerifiedEmail());
    }
    public function test_email_is_not_verified_with_invalid_user_id(): void
    {
        $user = User::factory()->unverified()->create();
        Event::fake();
        $verificationUrl = URL::temporarySignedRoute(
            'verification.verify',
            now()->addMinutes(60),
            ['id' => 123, 'hash' => sha1($user->email)],
        );
        $this->actingAs($user)->get($verificationUrl);
        Event::assertNotDispatched(Verified::class);
        $this->assertFalse($user->fresh()->hasVerifiedEmail());
    }
    public function test_verified_user_is_redirected_to_dashboard_from_verification_prompt(): void
    {
        $user = User::factory()->create();
        Event::fake();
        $response = $this->actingAs($user)->get(route('verification.notice'));
        Event::assertNotDispatched(Verified::class);
        $response->assertRedirect(route('dashboard', absolute: false));
    }
    public function test_already_verified_user_visiting_verification_link_is_redirected_without_firing_event_again(): void
    {
        $user = User::factory()->create();
        Event::fake();
        $verificationUrl = URL::temporarySignedRoute(
            'verification.verify',
            now()->addMinutes(60),
            ['id' => $user->id, 'hash' => sha1($user->email)],
        );
        $this->actingAs($user)->get($verificationUrl)
            ->assertRedirect(route('dashboard', absolute: false).'?verified=1');
        Event::assertNotDispatched(Verified::class);
        $this->assertTrue($user->fresh()->hasVerifiedEmail());
    }
 }
--- a/tests/Feature/Auth/PasswordConfirmationTest.php
+++ b/tests/Feature/Auth/PasswordConfirmationTest.php
@@ -1,33 +0,0 @@
 <?php
 namespace Tests\Feature\Auth;
 use App\Models\User;
 use Illuminate\Foundation\Testing\RefreshDatabase;
 use Inertia\Testing\AssertableInertia as Assert;
 use Tests\TestCase;
 class PasswordConfirmationTest extends TestCase
 {
    use RefreshDatabase;
    public function test_confirm_password_screen_can_be_rendered()
    {
        $user = User::factory()->create();
        $response = $this->actingAs($user)->get(route('password.confirm'));
        $response->assertOk();
        $response->assertInertia(fn (Assert $page) => $page
            ->component('auth/ConfirmPassword'),
        );
    }
    public function test_password_confirmation_requires_authentication()
    {
        $response = $this->get(route('password.confirm'));
        $response->assertRedirect(route('login'));
    }
 }
--- a/tests/Feature/Auth/PasswordResetTest.php
+++ b/tests/Feature/Auth/PasswordResetTest.php
@@ -1,87 +0,0 @@
 <?php
 namespace Tests\Feature\Auth;
 use App\Models\User;
 use Illuminate\Auth\Notifications\ResetPassword;
 use Illuminate\Foundation\Testing\RefreshDatabase;
 use Illuminate\Support\Facades\Notification;
 use Tests\TestCase;
 class PasswordResetTest extends TestCase
 {
    use RefreshDatabase;
    public function test_reset_password_link_screen_can_be_rendered()
    {
        $response = $this->get(route('password.request'));
        $response->assertOk();
    }
    public function test_reset_password_link_can_be_requested()
    {
        Notification::fake();
        $user = User::factory()->create();
        $this->post(route('password.email'), ['email' => $user->email]);
        Notification::assertSentTo($user, ResetPassword::class);
    }
    public function test_reset_password_screen_can_be_rendered()
    {
        Notification::fake();
        $user = User::factory()->create();
        $this->post(route('password.email'), ['email' => $user->email]);
        Notification::assertSentTo($user, ResetPassword::class, function ($notification) {
            $response = $this->get(route('password.reset', $notification->token));
            $response->assertOk();
            return true;
        });
    }
    public function test_password_can_be_reset_with_valid_token()
    {
        Notification::fake();
        $user = User::factory()->create();
        $this->post(route('password.email'), ['email' => $user->email]);
        Notification::assertSentTo($user, ResetPassword::class, function ($notification) use ($user) {
            $response = $this->post(route('password.update'), [
                'token' => $notification->token,
                'email' => $user->email,
                'password' => 'password',
                'password_confirmation' => 'password',
            ]);
            $response
                ->assertSessionHasNoErrors()
                ->assertRedirect(route('login'));
            return true;
        });
    }
    public function test_password_cannot_be_reset_with_invalid_token(): void
    {
        $user = User::factory()->create();
        $response = $this->post(route('password.update'), [
            'token' => 'invalid-token',
            'email' => $user->email,
            'password' => 'newpassword123',
            'password_confirmation' => 'newpassword123',
        ]);
        $response->assertSessionHasErrors('email');
    }
 }
--- a/tests/Feature/Auth/RegistrationTest.php
+++ b/tests/Feature/Auth/RegistrationTest.php
@@ -1,31 +0,0 @@
 <?php
 namespace Tests\Feature\Auth;
 use Illuminate\Foundation\Testing\RefreshDatabase;
 use Tests\TestCase;
 class RegistrationTest extends TestCase
 {
    use RefreshDatabase;
    public function test_registration_screen_can_be_rendered()
    {
        $response = $this->get(route('register'));
        $response->assertOk();
    }
    public function test_new_users_can_register()
    {
        $response = $this->post(route('register.store'), [
            'name' => 'Test User',
            'email' => 'test@example.com',
            'password' => 'password',
            'password_confirmation' => 'password',
        ]);
        $this->assertAuthenticated();
        $response->assertRedirect(route('dashboard', absolute: false));
    }
 }
--- a/tests/Feature/Auth/TwoFactorChallengeTest.php
+++ b/tests/Feature/Auth/TwoFactorChallengeTest.php
@@ -1,56 +0,0 @@
 <?php
 namespace Tests\Feature\Auth;
 use App\Models\User;
 use Illuminate\Foundation\Testing\RefreshDatabase;
 use Inertia\Testing\AssertableInertia as Assert;
 use Laravel\Fortify\Features;
 use Tests\TestCase;
 class TwoFactorChallengeTest extends TestCase
 {
    use RefreshDatabase;
    public function test_two_factor_challenge_redirects_to_login_when_not_authenticated(): void
    {
        if (! Features::canManageTwoFactorAuthentication()) {
            $this->markTestSkipped('Two-factor authentication is not enabled.');
        }
        $response = $this->get(route('two-factor.login'));
        $response->assertRedirect(route('login'));
    }
    public function test_two_factor_challenge_can_be_rendered(): void
    {
        if (! Features::canManageTwoFactorAuthentication()) {
            $this->markTestSkipped('Two-factor authentication is not enabled.');
        }
        Features::twoFactorAuthentication([
            'confirm' => true,
            'confirmPassword' => true,
        ]);
        $user = User::factory()->create();
        $user->forceFill([
            'two_factor_secret' => encrypt('test-secret'),
            'two_factor_recovery_codes' => encrypt(json_encode(['code1', 'code2'])),
            'two_factor_confirmed_at' => now(),
        ])->save();
        $this->post(route('login'), [
            'email' => $user->email,
            'password' => 'password',
        ]);
        $this->get(route('two-factor.login'))
            ->assertOk()
            ->assertInertia(fn (Assert $page) => $page
                ->component('auth/TwoFactorChallenge'),
            );
    }
 }
--- a/tests/Feature/Auth/VerificationNotificationTest.php
+++ b/tests/Feature/Auth/VerificationNotificationTest.php
@@ -1,40 +0,0 @@
 <?php
 namespace Tests\Feature\Auth;
 use App\Models\User;
 use Illuminate\Auth\Notifications\VerifyEmail;
 use Illuminate\Foundation\Testing\RefreshDatabase;
 use Illuminate\Support\Facades\Notification;
 use Tests\TestCase;
 class VerificationNotificationTest extends TestCase
 {
    use RefreshDatabase;
    public function test_sends_verification_notification(): void
    {
        Notification::fake();
        $user = User::factory()->unverified()->create();
        $this->actingAs($user)
            ->post(route('verification.send'))
            ->assertRedirect(route('home'));
        Notification::assertSentTo($user, VerifyEmail::class);
    }
    public function test_does_not_send_verification_notification_if_email_is_verified(): void
    {
        Notification::fake();
        $user = User::factory()->create();
        $this->actingAs($user)
            ->post(route('verification.send'))
            ->assertRedirect(route('dashboard', absolute: false));
        Notification::assertNothingSent();
    }
 }
--- a/tests/Feature/DashboardTest.php
+++ b/tests/Feature/DashboardTest.php
@@ -1,27 +0,0 @@
 <?php
 namespace Tests\Feature;
 use App\Models\User;
 use Illuminate\Foundation\Testing\RefreshDatabase;
 use Tests\TestCase;
 class DashboardTest extends TestCase
 {
    use RefreshDatabase;
    public function test_guests_are_redirected_to_the_login_page()
    {
        $response = $this->get(route('dashboard'));
        $response->assertRedirect(route('login'));
    }
    public function test_authenticated_users_can_visit_the_dashboard()
    {
        $user = User::factory()->create();
        $this->actingAs($user);
        $response = $this->get(route('dashboard'));
        $response->assertOk();
    }
 }
--- a/tests/Feature/Settings/PasswordUpdateTest.php
+++ b/tests/Feature/Settings/PasswordUpdateTest.php
@@ -1,62 +0,0 @@
 <?php
 namespace Tests\Feature\Settings;
 use App\Models\User;
 use Illuminate\Foundation\Testing\RefreshDatabase;
 use Illuminate\Support\Facades\Hash;
 use Tests\TestCase;
 class PasswordUpdateTest extends TestCase
 {
    use RefreshDatabase;
    public function test_password_update_page_is_displayed()
    {
        $user = User::factory()->create();
        $response = $this
            ->actingAs($user)
            ->get(route('user-password.edit'));
        $response->assertOk();
    }
    public function test_password_can_be_updated()
    {
        $user = User::factory()->create();
        $response = $this
            ->actingAs($user)
            ->from(route('user-password.edit'))
            ->put(route('user-password.update'), [
                'current_password' => 'password',
                'password' => 'new-password',
                'password_confirmation' => 'new-password',
            ]);
        $response
            ->assertSessionHasNoErrors()
            ->assertRedirect(route('user-password.edit'));
        $this->assertTrue(Hash::check('new-password', $user->refresh()->password));
    }
    public function test_correct_password_must_be_provided_to_update_password()
    {
        $user = User::factory()->create();
        $response = $this
            ->actingAs($user)
            ->from(route('user-password.edit'))
            ->put(route('user-password.update'), [
                'current_password' => 'wrong-password',
                'password' => 'new-password',
                'password_confirmation' => 'new-password',
            ]);
        $response
            ->assertSessionHasErrors('current_password')
            ->assertRedirect(route('user-password.edit'));
    }
 }
--- a/tests/Feature/Settings/ProfileUpdateTest.php
+++ b/tests/Feature/Settings/ProfileUpdateTest.php
@@ -1,99 +0,0 @@
 <?php
 namespace Tests\Feature\Settings;
 use App\Models\User;
 use Illuminate\Foundation\Testing\RefreshDatabase;
 use Tests\TestCase;
 class ProfileUpdateTest extends TestCase
 {
    use RefreshDatabase;
    public function test_profile_page_is_displayed()
    {
        $user = User::factory()->create();
        $response = $this
            ->actingAs($user)
            ->get(route('profile.edit'));
        $response->assertOk();
    }
    public function test_profile_information_can_be_updated()
    {
        $user = User::factory()->create();
        $response = $this
            ->actingAs($user)
            ->patch(route('profile.update'), [
                'name' => 'Test User',
                'email' => 'test@example.com',
            ]);
        $response
            ->assertSessionHasNoErrors()
            ->assertRedirect(route('profile.edit'));
        $user->refresh();
        $this->assertSame('Test User', $user->name);
        $this->assertSame('test@example.com', $user->email);
        $this->assertNull($user->email_verified_at);
    }
    public function test_email_verification_status_is_unchanged_when_the_email_address_is_unchanged()
    {
        $user = User::factory()->create();
        $response = $this
            ->actingAs($user)
            ->patch(route('profile.update'), [
                'name' => 'Test User',
                'email' => $user->email,
            ]);
        $response
            ->assertSessionHasNoErrors()
            ->assertRedirect(route('profile.edit'));
        $this->assertNotNull($user->refresh()->email_verified_at);
    }
    public function test_user_can_delete_their_account()
    {
        $user = User::factory()->create();
        $response = $this
            ->actingAs($user)
            ->delete(route('profile.destroy'), [
                'password' => 'password',
            ]);
        $response
            ->assertSessionHasNoErrors()
            ->assertRedirect(route('home'));
        $this->assertGuest();
        $this->assertNull($user->fresh());
    }
    public function test_correct_password_must_be_provided_to_delete_account()
    {
        $user = User::factory()->create();
        $response = $this
            ->actingAs($user)
            ->from(route('profile.edit'))
            ->delete(route('profile.destroy'), [
                'password' => 'wrong-password',
            ]);
        $response
            ->assertSessionHasErrors('password')
            ->assertRedirect(route('profile.edit'));
        $this->assertNotNull($user->fresh());
    }
 }
--- a/tests/Feature/Settings/TwoFactorAuthenticationTest.php
+++ b/tests/Feature/Settings/TwoFactorAuthenticationTest.php
@@ -1,92 +0,0 @@
 <?php
 namespace Tests\Feature\Settings;
 use App\Models\User;
 use Illuminate\Foundation\Testing\RefreshDatabase;
 use Inertia\Testing\AssertableInertia as Assert;
 use Laravel\Fortify\Features;
 use Tests\TestCase;
 class TwoFactorAuthenticationTest extends TestCase
 {
    use RefreshDatabase;
    public function test_two_factor_settings_page_can_be_rendered()
    {
        if (! Features::canManageTwoFactorAuthentication()) {
            $this->markTestSkipped('Two-factor authentication is not enabled.');
        }
        Features::twoFactorAuthentication([
            'confirm' => true,
            'confirmPassword' => true,
        ]);
        $user = User::factory()->create();
        $this->actingAs($user)
            ->withSession(['auth.password_confirmed_at' => time()])
            ->get(route('two-factor.show'))
            ->assertInertia(fn (Assert $page) => $page
                ->component('settings/TwoFactor')
                ->where('twoFactorEnabled', false),
            );
    }
    public function test_two_factor_settings_page_requires_password_confirmation_when_enabled()
    {
        if (! Features::canManageTwoFactorAuthentication()) {
            $this->markTestSkipped('Two-factor authentication is not enabled.');
        }
        $user = User::factory()->create();
        Features::twoFactorAuthentication([
            'confirm' => true,
            'confirmPassword' => true,
        ]);
        $response = $this->actingAs($user)
            ->get(route('two-factor.show'));
        $response->assertRedirect(route('password.confirm'));
    }
    public function test_two_factor_settings_page_does_not_requires_password_confirmation_when_disabled()
    {
        if (! Features::canManageTwoFactorAuthentication()) {
            $this->markTestSkipped('Two-factor authentication is not enabled.');
        }
        $user = User::factory()->create();
        Features::twoFactorAuthentication([
            'confirm' => true,
            'confirmPassword' => false,
        ]);
        $this->actingAs($user)
            ->get(route('two-factor.show'))
            ->assertOk()
            ->assertInertia(fn (Assert $page) => $page
                ->component('settings/TwoFactor'),
            );
    }
    public function test_two_factor_settings_page_returns_forbidden_response_when_two_factor_is_disabled()
    {
        if (! Features::canManageTwoFactorAuthentication()) {
            $this->markTestSkipped('Two-factor authentication is not enabled.');
        }
        config(['fortify.features' => []]);
        $user = User::factory()->create();
        $this->actingAs($user)
            ->withSession(['auth.password_confirmed_at' => time()])
            ->get(route('two-factor.show'))
            ->assertForbidden();
    }
 }
Author	SHA1	Message	Date
Matthias Guillitte	a99108649c	Removed unused tests Some checks failed linter / quality (push) Failing after 3m51s Details tests / ci (8.4) (push) Successful in 3m41s Details tests / ci (8.5) (push) Has been cancelled Details	2026-03-21 10:11:56 +01:00
Matthias Guillitte	946d6b0e68	Added README	2026-03-21 10:10:22 +01:00