Skip to content

A free open source IT asset/license management system

15.9 KB
Raw Blame
<?php

namespace Tests\Feature\Users\Ui\BulkActions;

use App\Models\Accessory;
use App\Models\Asset;
use App\Models\CheckoutAcceptance;
use App\Models\Consumable;
use App\Models\License;
use App\Models\LicenseSeat;
use App\Models\Statuslabel;
use App\Models\User;
use Illuminate\Database\Eloquent\Model;
use Tests\TestCase;

class BulkDeleteUsersTest extends TestCase
{
    public function test_requires_correct_permission()
    {
        $this->actingAs(User::factory()->create())
            ->post(route('users/bulksave'), [
                'ids' => [
                    User::factory()->create()->id,
                ],
                'status_id' => Statuslabel::factory()->create()->id,
            ])
            ->assertForbidden();
    }

    public function test_validation()
    {
        $user = User::factory()->create();
        Asset::factory()->assignedToUser($user)->create();

        $actor = $this->actingAs(User::factory()->editUsers()->create());

        // "ids" required
        $actor->post(route('users/bulksave'), [
            // 'ids' => [
            //     $user->id,
            // ],
            'status_id' => Statuslabel::factory()->create()->id,
        ])->assertSessionHas('error')->assertRedirect();

        // "status_id" needed when provided users have assets associated
        $actor->post(route('users/bulksave'), [
            'ids' => [
                $user->id,
            ],
            // 'status_id' => Statuslabel::factory()->create()->id,
        ])->assertSessionHas('error')->assertRedirect();
    }

    public function test_cannot_perform_bulk_actions_on_self()
    {
        $actor = User::factory()->editUsers()->create();

        $this->actingAs($actor)
            ->post(route('users/bulksave'), [
                'ids' => [
                    $actor->id,
                ],
                'delete_user' => '1',
            ])
            ->assertRedirect(route('users.index'))
            ->assertSessionHas('success', trans('general.bulk_checkin_delete_success'));

        $this->assertNotSoftDeleted($actor);
    }

    public function test_user_cannot_perform_bulk_actions_on_admin()
    {
        $actor = User::factory()->editUsers()->create();
        $admin = User::factory()->admin()->create();

        $this->actingAs($actor)
            ->post(route('users/bulksave'), [
                'ids' => [
                    $admin->id,
                ],
                'delete_user' => '1',
            ])
            ->assertRedirect(route('users.index'))
            ->assertSessionHas('error', trans('general.insufficient_permissions'));

        $this->assertNotSoftDeleted($admin);
    }

    public function test_admin_cannot_perform_bulk_actions_on_superadmin()
    {
        $admin = User::factory()->admin()->create();
        $superadmin = User::factory()->superuser()->create();

        $this->actingAs($admin)
            ->post(route('users/bulksave'), [
                'ids' => [
                    $superadmin->id,
                ],
                'delete_user' => '1',
            ])
            ->assertRedirect(route('users.index'))
            ->assertSessionHas('success', trans('general.bulk_checkin_delete_success'));

        $this->assertNotSoftDeleted($superadmin);
    }

    public function test_accessories_can_be_bulk_checked_in()
    {
        [$accessoryA, $accessoryB] = Accessory::factory()->count(2)->create();
        [$userA, $userB, $userC] = User::factory()->count(3)->create();

        // Add checkouts for multiple accessories to multiple users to get different ids in the mix
        $this->attachAccessoryToUsers($accessoryA, [$userA, $userB, $userC]);
        $this->attachAccessoryToUsers($accessoryB, [$userA, $userB]);

        $this->actingAs(User::factory()->editUsers()->checkinAccessories()->create())
            ->post(route('users/bulksave'), [
                'ids' => [
                    $userA->id,
                    $userC->id,
                ],
                'status_id' => Statuslabel::factory()->create()->id,
            ])
            ->assertRedirect(route('users.index'));

        $this->assertTrue($userA->fresh()->accessories->isEmpty());
        $this->assertTrue($userB->fresh()->accessories->isNotEmpty());
        $this->assertTrue($userC->fresh()->accessories->isEmpty());

        // These assertions check against a bug where the wrong value from
        // accessories_users was being populated in action_logs.item_id.
        $this->assertActionLogCheckInEntryFor($userA, $accessoryA);
        $this->assertActionLogCheckInEntryFor($userA, $accessoryB);
        $this->assertActionLogCheckInEntryFor($userC, $accessoryA);
    }

    public function test_assets_can_be_bulk_checked_in()
    {
        [$userA, $userB, $userC] = User::factory()->count(3)->create();

        $assetForUserA = $this->assignAssetToUser($userA);
        $lonelyAsset = $this->assignAssetToUser($userB);
        $assetForUserC = $this->assignAssetToUser($userC);

        $this->actingAs(User::factory()->editUsers()->checkinAssets()->create())
            ->post(route('users/bulksave'), [
                'ids' => [
                    $userA->id,
                    $userC->id,
                ],
                'status_id' => Statuslabel::factory()->create()->id,
            ])
            ->assertRedirect(route('users.index'));

        $this->assertTrue($userA->fresh()->assets->isEmpty());
        $this->assertTrue($userB->fresh()->assets->isNotEmpty());
        $this->assertTrue($userC->fresh()->assets->isEmpty());

        $this->assertActionLogCheckInEntryFor($userA, $assetForUserA);
        $this->assertActionLogCheckInEntryFor($userC, $assetForUserC);
    }

    public function test_consumables_can_be_bulk_checked_in()
    {
        [$consumableA, $consumableB] = Consumable::factory()->count(2)->create();
        [$userA, $userB, $userC] = User::factory()->count(3)->create();

        // Add checkouts for multiple consumables to multiple users to get different ids in the mix
        $this->attachConsumableToUsers($consumableA, [$userA, $userB, $userC]);
        $this->attachConsumableToUsers($consumableB, [$userA, $userB]);

        $this->actingAs(User::factory()->editUsers()->create())
            ->post(route('users/bulksave'), [
                'ids' => [
                    $userA->id,
                    $userC->id,
                ],
                'status_id' => Statuslabel::factory()->create()->id,
            ])
            ->assertRedirect(route('users.index'));

        $this->assertTrue($userA->fresh()->consumables->isEmpty());
        $this->assertTrue($userB->fresh()->consumables->isNotEmpty());
        $this->assertTrue($userC->fresh()->consumables->isEmpty());

        // Consumable checkin should not be logged.
        $this->assertNoActionLogCheckInEntryFor($userA, $consumableA);
        $this->assertNoActionLogCheckInEntryFor($userA, $consumableB);
        $this->assertNoActionLogCheckInEntryFor($userC, $consumableA);
    }

    public function test_license_seats_can_be_bulk_checked_in()
    {
        [$userA, $userB, $userC] = User::factory()->count(3)->create();

        $licenseSeatForUserA = LicenseSeat::factory()->assignedToUser($userA)->create();
        $lonelyLicenseSeat = LicenseSeat::factory()->assignedToUser($userB)->create();
        $licenseSeatForUserC = LicenseSeat::factory()->assignedToUser($userC)->create();

        $this->actingAs(User::factory()->editUsers()->checkinLicenses()->create())
            ->post(route('users/bulksave'), [
                'ids' => [
                    $userA->id,
                    $userC->id,
                ],
            ])
            ->assertRedirect(route('users.index'))
            ->assertSessionHas('success', trans('general.bulk_checkin_success'));

        $this->assertDatabaseMissing('license_seats', [
            'license_id' => $licenseSeatForUserA->license->id,
            'assigned_to' => $userA->id,
        ]);

        $this->assertDatabaseMissing('license_seats', [
            'license_id' => $licenseSeatForUserC->license->id,
            'assigned_to' => $userC->id,
        ]);

        // Slightly different from the other assertions since we use
        // the license and not the license seat in this case.
        $this->assertDatabaseHas('action_logs', [
            'action_type' => 'checkin from',
            'target_id' => $userA->id,
            'target_type' => User::class,
            'note' => 'Bulk checkin items on user bulk edit/delete',
            'item_type' => License::class,
            'item_id' => $licenseSeatForUserA->license->id,
        ]);

        $this->assertDatabaseHas('action_logs', [
            'action_type' => 'checkin from',
            'target_id' => $userC->id,
            'target_type' => User::class,
            'note' => 'Bulk checkin items on user bulk edit/delete',
            'item_type' => License::class,
            'item_id' => $licenseSeatForUserC->license->id,
        ]);
    }

    public function test_bulk_checkin_clears_pending_acceptances_for_the_selected_users()
    {
        $user = User::factory()->create();

        $asset = $this->assignAssetToUser($user);
        $licenseSeat = LicenseSeat::factory()->assignedToUser($user)->create();
        $accessory = Accessory::factory()->create();
        $consumable = Consumable::factory()->create();

        $this->attachAccessoryToUsers($accessory, [$user]);
        $this->attachConsumableToUsers($consumable, [$user]);

        $acceptances = [
            $this->pendingAcceptanceFor(Asset::class, $asset->id, $user),
            $this->pendingAcceptanceFor(LicenseSeat::class, $licenseSeat->id, $user),
            $this->pendingAcceptanceFor(Accessory::class, $accessory->id, $user),
            $this->pendingAcceptanceFor(Consumable::class, $consumable->id, $user),
        ];

        $this->actingAs(User::factory()->editUsers()->checkinAssets()->checkinAccessories()->checkinLicenses()->create())
            ->post(route('users/bulksave'), [
                'ids' => [
                    $user->id,
                ],
                'status_id' => Statuslabel::factory()->create()->id,
            ])
            ->assertRedirect(route('users.index'));

        // Confirm the checkin actually happened, or the assertions below
        // would pass against a request that bailed out early.
        $this->assertTrue($user->fresh()->assets->isEmpty());
        $this->assertTrue($user->fresh()->accessories->isEmpty());
        $this->assertTrue($user->fresh()->consumables->isEmpty());

        foreach ($acceptances as $acceptance) {
            $this->assertAcceptanceWasSoftDeleted($acceptance);
        }
    }

    public function test_bulk_checkin_leaves_untargeted_users_pending_acceptances_alone()
    {
        [$targeted, $untargeted] = User::factory()->count(2)->create();

        $accessory = Accessory::factory()->create();
        $this->attachAccessoryToUsers($accessory, [$targeted, $untargeted]);

        $targetedAcceptance = $this->pendingAcceptanceFor(Accessory::class, $accessory->id, $targeted);
        $untargetedAcceptance = $this->pendingAcceptanceFor(Accessory::class, $accessory->id, $untargeted);

        $this->actingAs(User::factory()->editUsers()->checkinAccessories()->create())
            ->post(route('users/bulksave'), [
                'ids' => [
                    $targeted->id,
                ],
                'status_id' => Statuslabel::factory()->create()->id,
            ])
            ->assertRedirect(route('users.index'));

        $this->assertAcceptanceWasSoftDeleted($targetedAcceptance);
        $this->assertAcceptanceSurvived($untargetedAcceptance);
    }

    public function test_bulk_checkin_leaves_answered_acceptances_alone()
    {
        $user = User::factory()->create();
        $asset = $this->assignAssetToUser($user);

        $accepted = CheckoutAcceptance::factory()->withoutActionLog()->accepted()->create([
            'checkoutable_type' => Asset::class,
            'checkoutable_id' => $asset->id,
            'assigned_to_id' => $user->id,
        ]);

        $declined = CheckoutAcceptance::factory()->withoutActionLog()->declined()->create([
            'checkoutable_type' => Asset::class,
            'checkoutable_id' => $asset->id,
            'assigned_to_id' => $user->id,
        ]);

        $this->actingAs(User::factory()->editUsers()->checkinAssets()->create())
            ->post(route('users/bulksave'), [
                'ids' => [
                    $user->id,
                ],
                'status_id' => Statuslabel::factory()->create()->id,
            ])
            ->assertRedirect(route('users.index'));

        $this->assertAcceptanceSurvived($accepted);
        $this->assertAcceptanceSurvived($declined);
    }

    public function test_users_can_be_deleted_in_bulk()
    {
        [$userA, $userB, $userC] = User::factory()->count(3)->create();

        $this->actingAs(User::factory()->admin()->create())
            ->post(route('users/bulksave'), [
                'ids' => [
                    $userA->id,
                    $userC->id,
                ],
                'delete_user' => '1',
            ])
            ->assertRedirect(route('users.index'))
            ->assertSessionHas('success', trans('general.bulk_checkin_delete_success'));

        $this->assertSoftDeleted($userA);
        $this->assertNotSoftDeleted($userB);
        $this->assertSoftDeleted($userC);
    }

    private function assignAssetToUser(User $user): Asset
    {
        return Asset::factory()->assignedToUser($user)->create();
    }

    private function attachAccessoryToUsers(Accessory $accessory, array $users): void
    {
        foreach ($users as $user) {
            $accessoryCheckout = $accessory->checkouts()->make();
            $accessoryCheckout->assignedTo()->associate($user);
            $accessoryCheckout->save();
        }
    }

    private function attachConsumableToUsers(Consumable $consumable, array $users): void
    {
        foreach ($users as $user) {
            $consumable->users()->attach($consumable->id, [
                'consumable_id' => $consumable->id,
                'assigned_to' => $user->id,
            ]);
        }
    }

    private function pendingAcceptanceFor(string $checkoutableType, int $checkoutableId, User $user): CheckoutAcceptance
    {
        return CheckoutAcceptance::factory()->withoutActionLog()->pending()->create([
            'checkoutable_type' => $checkoutableType,
            'checkoutable_id' => $checkoutableId,
            'assigned_to_id' => $user->id,
        ]);
    }

    private function assertAcceptanceWasSoftDeleted(CheckoutAcceptance $acceptance): void
    {
        $this->assertNotNull(
            CheckoutAcceptance::withTrashed()->find($acceptance->id)?->deleted_at,
            'Expected the pending acceptance to be soft-deleted by the bulk checkin.'
        );
    }

    private function assertAcceptanceSurvived(CheckoutAcceptance $acceptance): void
    {
        $this->assertNull(
            CheckoutAcceptance::withTrashed()->find($acceptance->id)?->deleted_at,
            'Expected this acceptance to be left alone by the bulk checkin.'
        );
    }

    private function assertActionLogCheckInEntryFor(User $user, Model $model): void
    {
        $note = $model instanceof Accessory
            ? 'Bulk checkin accessory on user bulk edit/delete'
            : 'Bulk checkin items on user bulk edit/delete';

        $this->assertDatabaseHas('action_logs', [
            'action_type' => 'checkin from',
            'target_id' => $user->id,
            'target_type' => User::class,
            'note' => $note,
            'item_type' => get_class($model),
            'item_id' => $model->id,
        ]);
    }

    private function assertNoActionLogCheckInEntryFor(User $user, Model $model): void
    {
        $this->assertDatabaseMissing('action_logs', [
            'action_type' => 'checkin from',
            'target_id' => $user->id,
            'target_type' => User::class,
            'note' => 'Bulk checkin items on user bulk edit/delete',
            'item_type' => get_class($model),
            'item_id' => $model->id,
        ]);
    }
}