nexus/vuefilemanager
2
0
Fork 0
mirror of https://github.com/VueFileManager/vuefilemanager.git synced 2026-05-24 05:34:43 +00:00
Code Issues Packages Projects Releases Wiki Activity

deleted pro files

Browse Source
This commit is contained in:
Čarodej
2022-04-26 10:53:24 +02:00
parent 92561d137d
commit 188d5613b7
119 changed files with 607 additions and 10013 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/App/Restrictions/FixedBillingRestrictionsTest.php
-225
View File
@@ -1,225 +0,0 @@
<?php
namespace Tests\App\Restrictions;
use Tests\TestCase;
use App\Users\Models\User;
use Domain\Files\Models\File;
use Domain\Sharing\Models\Share;
use Domain\Settings\Models\Setting;
use Domain\Teams\Models\TeamFolderMember;
class FixedBillingRestrictionsTest extends TestCase
{
public function setUp(): void
{
parent::setUp();
Setting::updateOrCreate([
'name' => 'subscription_type',
], [
'value' => 'fixed',
]);
}
/**
* @test
*/
public function it_can_upload()
{
$user = User::factory()
->hasSettings()
->create();
$this->assertEquals(true, $user->canUpload(9999999));
}
/**
* @test
*/
public function it_cant_upload_because_storage_limit_exceeded()
{
$user = User::factory()
->hasSettings()
->create();
File::factory()
->create([
'user_id' => $user->id,
'filesize' => 99999999,
]);
$this->assertEquals(false, $user->canUpload(999999999));
}
/**
* @test
*/
public function it_can_create_new_folder()
{
$user = User::factory()
->hasSettings()
->create();
$this
->actingAs($user)
->postJson('/api/create-folder', [
'name' => 'New Folder',
])
->assertStatus(201);
$this->assertDatabaseHas('folders', [
'name' => 'New Folder',
]);
}
/**
* @test
*/
public function it_cant_invite_team_members_into_team_folder_because_user_exceeded_members_limit()
{
$user = User::factory()
->hasSettings()
->hasFolders([
'team_folder' => true,
])
->create();
TeamFolderMember::create([
'parent_id' => $user->folders[0]->id,
'user_id' => $user->id,
'permission' => 'owner',
]);
// Create team folder members
$members = User::factory()
->count(5)
->create()
->each(
fn ($member) => TeamFolderMember::factory()
->create([
'parent_id' => $user->folders[0]->id,
'user_id' => $member->id,
])
);
// Try invite new members, it has to fail
$this
->actingAs($user)
->post('/api/teams/folders', [
'name' => 'Company Project',
'invitations' => [
[
'email' => 'test@doe.com',
'permission' => 'can-edit',
],
[
'email' => 'test2@doe.com',
'permission' => 'can-edit',
],
[
'email' => 'test3@doe.com',
'permission' => 'can-edit',
],
[
'email' => 'test4@doe.com',
'permission' => 'can-edit',
],
[
'email' => 'test5@doe.com',
'permission' => 'can-edit',
],
[
'email' => 'test6@doe.com',
'permission' => 'can-edit',
],
],
])
->assertStatus(401);
// Invite existing member, it has to go through
$this
->actingAs($user)
->post('/api/teams/folders', [
'name' => 'Company Project',
'invitations' => [
[
'email' => $members[0]->email,
'permission' => 'can-edit',
],
],
])
->assertCreated();
}
/**
* @test
*/
public function it_can_get_private_file()
{
$user = User::factory()
->hasSettings()
->create();
$file = File::factory()
->create([
'user_id' => $user->id,
'basename' => 'fake-file.pdf',
'name' => 'fake-file.pdf',
]);
// 404 but, ok, because there is not stored temporary file in test
$this
->actingAs($user)
->get("file/$file->name")
->assertStatus(404);
}
/**
* @test
*/
public function it_can_get_shared_file()
{
$user = User::factory()
->hasSettings()
->create();
$file = File::factory()
->create([
'basename' => 'fake-file.pdf',
'name' => 'fake-file.pdf',
]);
$share = Share::factory()
->create([
'item_id' => $file->id,
'user_id' => $user->id,
'type' => 'file',
'is_protected' => false,
]);
// 404 but, ok, because there is not stored temporary file in test
$this
->get("file/$file->name/shared/$share->token")
->assertStatus(404);
}
/**
* @test
*/
public function it_can_get_share_page()
{
$user = User::factory()
->hasSettings()
->create();
$share = Share::factory()
->create([
'user_id' => $user->id,
'type' => 'folder',
'is_protected' => false,
]);
$this->get("/share/$share->token")
->assertRedirect("/share/$share->token/files/$share->item_id");
}
}
tests/App/Restrictions/MeteredBillingRestrictionsTest.php
-240
View File
@@ -1,240 +0,0 @@
<?php
namespace Tests\App\Restrictions;
use Tests\TestCase;
use App\Users\Models\User;
use Domain\Files\Models\File;
use Domain\Sharing\Models\Share;
use Domain\Settings\Models\Setting;
class MeteredBillingRestrictionsTest extends TestCase
{
public function setUp(): void
{
parent::setUp();
Setting::updateOrCreate([
'name' => 'subscription_type',
], [
'value' => 'metered',
]);
}
/**
* @test
*/
public function it_can_upload()
{
$user = User::factory()
->hasFailedpayments(2)
->create();
$this->assertEquals(true, $user->canUpload());
}
/**
* @test
*/
public function it_cant_upload_because_user_has_3_failed_payments()
{
$user = User::factory()
->hasFailedpayments(3)
->create();
$this->assertEquals(false, $user->canUpload());
}
/**
* @test
*/
public function it_can_create_new_folder()
{
$user = User::factory()
->hasSettings()
->create();
// Create basic folder
$this
->actingAs($user)
->postJson('/api/create-folder', [
'name' => 'New Folder',
])
->assertStatus(201);
// Create team folder
$this
->actingAs($user)
->postJson('/api/teams/folders', [
'name' => 'New Team Folder',
'invitations' => [
[
'email' => 'john@doe.com',
'permission' => 'can-edit',
'type' => 'invitation',
],
],
])
->assertStatus(201);
$this->assertDatabaseCount('folders', 2);
}
/**
* @test
*/
public function it_cant_create_new_folder_because_user_has_3_failed_payments()
{
$user = User::factory()
->hasFailedpayments(3)
->create();
// Create basic folder
$this
->actingAs($user)
->postJson('/api/create-folder', [
'name' => 'New Folder',
])
->assertStatus(401);
// Create team folder
$this
->actingAs($user)
->postJson('/api/teams/folders', [
'name' => 'New Folder',
'invitations' => [
[
'email' => 'john@doe.com',
'permission' => 'can-edit',
'type' => 'invitation',
],
],
])
->assertStatus(401);
$this->assertDatabaseCount('folders', 0);
}
/**
* @test
*/
public function it_cant_get_private_file_because_user_has_3_failed_payments()
{
$user = User::factory()
->hasFailedpayments(3)
->create();
$file = File::factory()
->create([
'user_id' => $user->id,
'basename' => 'fake-file.pdf',
'name' => 'fake-file.pdf',
]);
$this
->actingAs($user)
->get("file/$file->name")
->assertStatus(401);
}
/**
* @test
*/
public function it_can_get_private_file()
{
$user = User::factory()
->hasSettings()
->create();
$file = File::factory()
->create([
'user_id' => $user->id,
'basename' => 'fake-file.pdf',
'name' => 'fake-file.pdf',
]);
// 404 but, ok, because there is not stored temporary file in test
$this
->actingAs($user)
->get("file/$file->name")
->assertStatus(404);
}
/**
* @test
*/
public function it_cant_get_shared_file_because_user_has_3_failed_payments()
{
$user = User::factory()
->hasFailedpayments(3)
->create();
$file = File::factory()
->create([
'user_id' => $user->id,
'basename' => 'fake-file.pdf',
'name' => 'fake-file.pdf',
]);
$share = Share::factory()
->create([
'item_id' => $file->id,
'user_id' => $user->id,
'type' => 'file',
'is_protected' => false,
]);
$this
->get("file/$file->name/shared/$share->token")
->assertStatus(401);
}
/**
* @test
*/
public function it_can_get_shared_file()
{
$user = User::factory()
->hasSettings()
->create();
$file = File::factory()
->create([
'user_id' => $user->id,
'basename' => 'fake-file.pdf',
'name' => 'fake-file.pdf',
]);
$share = Share::factory()
->create([
'item_id' => $file->id,
'user_id' => $user->id,
'type' => 'file',
'is_protected' => false,
]);
// 404 but, ok, because there is not stored temporary file in test
$this
->get("file/$file->name/shared/$share->token")
->assertStatus(404);
}
/**
* @test
*/
public function it_cant_get_share_page()
{
$user = User::factory()
->hasFailedpayments(3)
->create();
$share = Share::factory()
->create([
'user_id' => $user->id,
'type' => 'folder',
'is_protected' => false,
]);
$this->get("/share/$share->token")
->assertRedirect('/temporary-unavailable');
}
}
tests/App/Socialite/SocialiteTest.php
-88
View File
@@ -1,88 +0,0 @@
<?php
namespace Tests\App\Socialite;
use Mockery;
use Storage;
use Tests\TestCase;
use App\Users\Models\User;
use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\Http;
use Laravel\Socialite\Two\FacebookProvider;
use Laravel\Socialite\Contracts\Factory as Socialite;
class SocialiteTest extends TestCase
{
/**
* @test
*/
public function socialite_redirect_user()
{
$response = $this->get('api/socialite/google/redirect');
$this->assertStringContainsString('accounts.google.com/o/oauth2/auth', $response['url']);
}
/**
* @test
*/
public function socialite_execute_provider_callback()
{
// Create fake image
$fakeImage = UploadedFile::fake()
->image('fake-avatar.jpg');
Http::fake([
'https://vuefilemanager.com/avatar.jpg' => Http::response($fakeImage->getContent()),
]);
// Create fake user
$socialiteUser = Mockery::mock(\Laravel\Socialite\Two\User::class);
$socialiteUser
->shouldReceive('getId')
->andReturn('fake_id')
->shouldReceive('getEmail')
->andReturn('howdy@hi5ve.digital')
->shouldReceive('getName')
->andReturn('Jane Doe')
->shouldReceive('getAvatar')
->andReturn('https://vuefilemanager.com/avatar.jpg');
// Mock user with FB provider
$provider = $this->createMock(FacebookProvider::class);
$provider->expects($this->any())
->method('user')
->willReturn($socialiteUser);
// Mock socialite
$stub = $this->createMock(Socialite::class);
$stub->expects($this->any())
->method('driver')
->willReturn($provider);
// Replace Socialite Instance with mock
$this->app->instance(Socialite::class, $stub);
$this->getJson('/socialite/facebook/callback')
->assertRedirect();
$this
->assertDatabaseHas('users', [
'email' => 'howdy@hi5ve.digital',
'oauth_provider' => 'facebook',
'password' => null,
])
->assertDatabaseHas('user_settings', [
'first_name' => 'Jane',
'last_name' => 'Doe',
]);
$user = User::first();
collect(config('vuefilemanager.avatar_sizes'))
->each(
fn ($size) => Storage::disk('local')
->assertExists("avatars/{$size['name']}-{$user->settings->getRawOriginal('avatar')}")
);
}
}
tests/App/Users/UserSubscriptionTest.php
-163
View File
@@ -1,163 +0,0 @@
<?php
namespace Tests\App\Users;
use Tests\TestCase;
use App\Users\Models\User;
use App\Users\Actions\FormatUsageEstimatesAction;
use VueFileManager\Subscription\Domain\Plans\Models\Plan;
use VueFileManager\Subscription\Domain\Plans\Models\PlanFixedFeature;
use VueFileManager\Subscription\Support\Events\SubscriptionWasCreated;
use VueFileManager\Subscription\Support\Events\SubscriptionWasExpired;
use VueFileManager\Subscription\Support\Events\SubscriptionWasUpdated;
class UserSubscriptionTest extends TestCase
{
/**
* @test
*/
public function it_set_user_limitations_for_new_subscription()
{
$plan = Plan::factory()
->has(PlanFixedFeature::factory()
->count(2)
->sequence(
[
'key' => 'max_storage_amount',
'value' => 200,
],
[
'key' => 'max_team_members',
'value' => 20,
],
), 'fixedFeatures')
->create();
$user = User::factory()
->hasSubscription([
'plan_id' => $plan->id,
])
->create();
SubscriptionWasCreated::dispatch($user->subscription);
$this->assertDatabaseHas('user_limitations', [
'max_storage_amount' => 200,
'max_team_members' => 20,
]);
}
/**
* @test
*/
public function it_set_user_limitations_for_updated_subscription()
{
$plan = Plan::factory()
->has(PlanFixedFeature::factory()
->count(2)
->sequence(
[
'key' => 'max_storage_amount',
'value' => 200,
],
[
'key' => 'max_team_members',
'value' => 20,
],
), 'fixedFeatures')
->create();
$user = User::factory()
->hasSubscription([
'plan_id' => $plan->id,
])
->create();
SubscriptionWasUpdated::dispatch($user->subscription);
$this->assertDatabaseHas('user_limitations', [
'max_storage_amount' => 200,
'max_team_members' => 20,
]);
}
/**
* @test
*/
public function it_set_user_limitations_for_expired_subscription()
{
$user = User::factory()
->hasSubscription()
->create();
$user->limitations()->update([
'max_storage_amount' => 200,
'max_team_members' => 20,
]);
SubscriptionWasExpired::dispatch($user->subscription);
$this->assertDatabaseHas('user_limitations', [
'max_storage_amount' => 5,
'max_team_members' => 5,
]);
}
/**
* @test
*/
public function it_format_price_estimates()
{
$usages = collect([
[
'feature' => 'bandwidth',
'amount' => 7.54696,
'usage' => 2.6024,
], [
'feature' => 'storage',
'amount' => 0.47628,
'usage' => 3.969,
], [
'feature' => 'flatFee',
'amount' => 2.49,
'usage' => 1,
], [
'feature' => 'member',
'amount' => 0.20,
'usage' => 2,
],
]);
// Format usage estimates
$estimates = resolve(FormatUsageEstimatesAction::class)('USD', $usages)
->toArray();
$expected = [
'bandwidth' => [
'feature' => 'bandwidth',
'amount' => 7.54696,
'cost' => '$7.55',
'usage' => '2.60GB',
],
'storage' => [
'feature' => 'storage',
'amount' => 0.47628,
'cost' => '$0.48',
'usage' => '3.97GB',
],
'flatFee' => [
'feature' => 'flatFee',
'amount' => 2.49,
'cost' => '$2.49',
'usage' => '1 Pcs.',
],
'member' => [
'feature' => 'member',
'amount' => 0.20,
'cost' => '$0.20',
'usage' => '2 Mem.',
],
];
$this->assertEquals($expected, $estimates);
}
}
tests/Domain/Notifications/NotificationsTest.php
-133
View File
@@ -1,133 +0,0 @@
<?php
namespace Tests\Domain\Notifications;
use DB;
use Str;
use Tests\TestCase;
use App\Users\Models\User;
class NotificationsTest extends TestCase
{
/**
* @test
*/
public function it_get_all_notifications()
{
$user = User::factory()
->hasSettings()
->create();
DB::table('notifications')
->insert([
'id' => Str::uuid(),
'type' => 'Domain\UploadRequest\Notifications\UploadRequestFulfilledNotification',
'notifiable_type' => 'App\Users\Models\User',
'notifiable_id' => $user->id,
'data' => json_encode([
'category' => 'file-request',
'title' => 'File Request Filled',
'description' => "Your file request for 'Documents' folder was filled successfully.",
'action' => [
'type' => 'route',
'params' => [
'route' => 'Files',
'button' => 'Show Files',
'id' => Str::uuid(),
],
],
]),
'created_at' => now(),
'updated_at' => now(),
]);
$this
->actingAs($user)
->getJson('/api/user/notifications')
->assertJsonFragment([
'category' => 'file-request',
])
->assertStatus(200);
}
/**
* @test
*/
public function it_mark_as_read_notifications()
{
$user = User::factory()
->hasSettings()
->create();
DB::table('notifications')
->insert([
'id' => Str::uuid(),
'type' => 'Domain\UploadRequest\Notifications\UploadRequestFulfilledNotification',
'notifiable_type' => 'App\Users\Models\User',
'notifiable_id' => $user->id,
'data' => json_encode([
'type' => 'file-request',
'title' => 'File Request Filled',
'description' => "Your file request for 'Documents' folder was filled successfully.",
'action' => [
'type' => 'route',
'params' => [
'route' => 'Files',
'button' => 'Show Files',
'id' => Str::uuid(),
],
],
]),
'created_at' => now(),
'updated_at' => now(),
]);
$this
->actingAs($user)
->postJson('/api/user/notifications/read')
->assertStatus(204);
$this->assertDatabaseHas('notifications', [
'read_at' => now(),
]);
}
/**
* @test
*/
public function it_delete_all_notifications()
{
$user = User::factory()
->hasSettings()
->create();
DB::table('notifications')
->insert([
'id' => Str::uuid(),
'type' => 'Domain\UploadRequest\Notifications\UploadRequestFulfilledNotification',
'notifiable_type' => 'App\Users\Models\User',
'notifiable_id' => $user->id,
'data' => json_encode([
'type' => 'file-request',
'title' => 'File Request Filled',
'description' => "Your file request for 'Documents' folder was filled successfully.",
'action' => [
'type' => 'route',
'params' => [
'route' => 'Files',
'button' => 'Show Files',
'id' => Str::uuid(),
],
],
]),
'created_at' => now(),
'updated_at' => now(),
]);
$this
->actingAs($user)
->deleteJson('/api/user/notifications')
->assertStatus(204);
$this->assertDatabaseCount('notifications', 0);
}
}
tests/Domain/Pages/AdminPagesTest.php
-73
View File
@@ -1,73 +0,0 @@
<?php
namespace Tests\Domain\Pages;
use Tests\TestCase;
use App\Users\Models\User;
use Laravel\Sanctum\Sanctum;
use Domain\Pages\Actions\SeedDefaultPagesAction;
class AdminPagesTest extends TestCase
{
/**
* @test
*/
public function it_get_all_pages()
{
resolve(SeedDefaultPagesAction::class)();
$admin = User::factory()
->create(['role' => 'admin']);
Sanctum::actingAs($admin);
collect(['terms-of-service', 'privacy-policy', 'cookie-policy'])
->each(function ($slug) {
$this->getJson('/api/admin/pages')
->assertStatus(200)
->assertJsonFragment([
'slug' => $slug,
]);
});
}
/**
* @test
*/
public function it_get_page()
{
resolve(SeedDefaultPagesAction::class)();
$admin = User::factory()
->create(['role' => 'admin']);
$this
->actingAs($admin)
->getJson('/api/admin/pages/terms-of-service')
->assertStatus(200)
->assertJsonFragment([
'slug' => 'terms-of-service',
]);
}
/**
* @test
*/
public function it_update_page()
{
resolve(SeedDefaultPagesAction::class)();
$admin = User::factory()
->create(['role' => 'admin']);
$this
->actingAs($admin)
->patchJson('/api/admin/pages/terms-of-service', [
'name' => 'title',
'value' => 'New Title',
])->assertStatus(204);
$this->assertDatabaseHas('pages', [
'title' => 'New Title',
]);
}
}
tests/Domain/Pages/PagesTest.php
-22
View File
@@ -1,22 +0,0 @@
<?php
namespace Tests\Domain\Pages;
use Tests\TestCase;
use Domain\Pages\Actions\SeedDefaultPagesAction;
class PagesTest extends TestCase
{
/**
* @test
*/
public function it_get_legal_page()
{
resolve(SeedDefaultPagesAction::class)();
$this->getJson('/api/page/terms-of-service')
->assertStatus(200)
->assertJsonFragment([
'title' => 'Terms of Service',
]);
}
}
tests/Domain/Teams/TeamFileAccessTest.php
-112
View File
@@ -1,112 +0,0 @@
<?php
namespace Tests\Domain\Teams;
use Tests\TestCase;
use App\Users\Models\User;
use Domain\Files\Models\File;
use Domain\Folders\Models\Folder;
use Illuminate\Http\UploadedFile;
use Domain\Teams\Models\TeamFolderMember;
class TeamFileAccessTest extends TestCase
{
/**
* @test
*/
public function team_member_download_folder_as_zip()
{
$user = User::factory()
->hasSettings()
->create();
$folder = Folder::factory()
->create([
'user_id' => $user->id,
]);
collect([0, 1])
->each(function ($index) use ($folder, $user) {
$file = UploadedFile::fake()
->create("fake-file-$index.pdf", 1200, 'application/pdf');
$this
->actingAs($user)
->postJson('/api/upload', [
'name' => $file->name,
'extension' => 'pdf',
'file' => $file,
'parent_id' => $folder->id,
'path' => "/$file->name",
'is_last' => 'true',
])->assertStatus(201);
});
$member = User::factory()
->hasSettings()
->create();
// Attach user into members
TeamFolderMember::create([
'parent_id' => $folder->id,
'user_id' => $member->id,
'permission' => 'can-edit',
]);
$this
->actingAs($member)
->getJson("/api/zip?items=$folder->id|folder")
->assertStatus(200)
->assertHeader('content-type', 'application/x-zip');
}
/**
* @test
*/
public function team_member_download_files_as_zip()
{
$user = User::factory()
->hasSettings()
->create();
$folder = Folder::factory()
->create([
'user_id' => $user->id,
]);
collect([0, 1])
->each(function ($index) use ($folder, $user) {
$file = UploadedFile::fake()
->create("fake-file-$index.pdf", 1200, 'application/pdf');
$this
->actingAs($user)
->postJson('/api/upload', [
'name' => $file->name,
'extension' => 'pdf',
'file' => $file,
'parent_id' => $folder->id,
'path' => "/$file->name",
'is_last' => 'true',
])->assertStatus(201);
});
$member = User::factory()
->hasSettings()
->create();
// Attach user into members
TeamFolderMember::create([
'parent_id' => $folder->id,
'user_id' => $member->id,
'permission' => 'can-edit',
]);
$files = File::all();
$this
->actingAs($member)
->getJson("/api/zip?items={$files->first()->id}|file,{$files->last()->id}|file")
->assertStatus(200)
->assertHeader('content-type', 'application/x-zip');
}
}
tests/Domain/Teams/TeamManagementTest.php
-758
View File
@@ -1,758 +0,0 @@
<?php
namespace Tests\Domain\Teams;
use Str;
use Notification;
use Tests\TestCase;
use App\Users\Models\User;
use Domain\Folders\Models\Folder;
use Illuminate\Support\Facades\DB;
use Domain\Teams\Models\TeamFolderInvitation;
use Domain\Teams\Notifications\InvitationIntoTeamFolder;
class TeamManagementTest extends TestCase
{
/**
* @test
*/
public function it_get_team_folder_invite()
{
[$inviter, $member] = User::factory()
->hasSettings()
->count(2)
->create();
$invitation = TeamFolderInvitation::factory()
->create([
'inviter_id' => $inviter->id,
'parent_id' => Str::uuid(),
'email' => $member->email,
'status' => 'pending',
'permission' => 'can-edit',
]);
$this->getJson("/api/teams/invitations/{$invitation->id}")
->assertOk()
->assertJsonFragment([
'name' => $inviter->settings->name,
]);
}
/**
* @test
*/
public function it_accept_team_folder_invite_as_registered_user()
{
$member = User::factory()
->create([
'email' => 'john@internal.com',
]);
$folder = Folder::factory()
->create();
$invitation = TeamFolderInvitation::factory()
->create([
'parent_id' => $folder->id,
'email' => $member->email,
'status' => 'pending',
'permission' => 'can-view',
]);
DB::table('notifications')
->insert([
'id' => Str::uuid(),
'type' => 'Domain\UploadRequest\Notifications\UploadRequestFulfilledNotification',
'notifiable_type' => 'App\Users\Models\User',
'notifiable_id' => $member->id,
'data' => json_encode([
'type' => 'team-invitation',
'title' => 'New Team Invitation',
'description' => 'Jane Doe invite you to join into Team Folder..',
'action' => [
'type' => 'invitation',
'params' => [
'type' => 'invitation',
'params' => [
'id' => $invitation->id,
],
],
],
]),
'created_at' => now(),
'updated_at' => now(),
]);
$this
->actingAs($member)
->putJson("/api/teams/invitations/{$invitation->id}")
->assertNoContent();
// Get notification
$notification = json_decode(DB::table('notifications')->first()->data);
// Check if action is null
$this->assertEquals(null, $notification->action);
$this
->assertDatabaseHas('team_folder_invitations', [
'parent_id' => $folder->id,
'status' => 'accepted',
])
->assertDatabaseHas('team_folder_members', [
'parent_id' => $folder->id,
'user_id' => $member->id,
'permission' => 'can-view',
]);
}
/**
* @test
*/
public function it_accept_team_folder_invite_as_guest_user()
{
$folder = Folder::factory()
->create();
$invitation = TeamFolderInvitation::factory()
->create([
'parent_id' => $folder->id,
'email' => 'howdy@hi5ve.digital',
'status' => 'pending',
'permission' => 'can-edit',
]);
$this
->putJson("/api/teams/invitations/{$invitation->id}")
->assertNoContent();
$this
->assertDatabaseHas('team_folder_invitations', [
'parent_id' => $folder->id,
'status' => 'waiting-for-registration',
])
->assertDatabaseMissing('team_folder_members', [
'parent_id' => $folder->id,
'permission' => 'can-edit',
]);
}
/**
* @test
*/
public function it_apply_accepted_invitation_after_user_registration()
{
$invitation = TeamFolderInvitation::factory()
->create([
'email' => 'john@doe.com',
'status' => 'waiting-for-registration',
]);
$this->postJson('api/register', [
'email' => 'john@doe.com',
'password' => 'SecretPassword',
'password_confirmation' => 'SecretPassword',
'name' => 'John Doe',
])->assertStatus(201);
$this
->assertDatabaseHas('team_folder_invitations', [
'parent_id' => $invitation->parent_id,
'status' => 'accepted',
])
->assertDatabaseHas('team_folder_members', [
'parent_id' => $invitation->parent_id,
'user_id' => User::first()->id,
'permission' => $invitation->permission,
]);
}
/**
* @test
*/
public function it_get_used_team_folder_invite()
{
$invitation = TeamFolderInvitation::factory()
->create(['status' => 'accepted']);
$this
->getJson("/api/teams/invitations/{$invitation->id}")
->assertStatus(410);
}
/**
* @test
*/
public function it_reject_team_folder_invite()
{
$member = User::factory()
->create([
'email' => 'john@internal.com',
]);
$folder = Folder::factory()
->create();
$invitation = TeamFolderInvitation::factory()
->create([
'parent_id' => $folder->id,
'email' => $member->email,
'status' => 'pending',
'permission' => 'can-edit',
]);
DB::table('notifications')
->insert([
'id' => Str::uuid(),
'type' => 'Domain\UploadRequest\Notifications\UploadRequestFulfilledNotification',
'notifiable_type' => 'App\Users\Models\User',
'notifiable_id' => $member->id,
'data' => json_encode([
'type' => 'team-invitation',
'title' => 'New Team Invitation',
'description' => 'Jane Doe invite you to join into Team Folder..',
'action' => [
'type' => 'invitation',
'params' => [
'type' => 'invitation',
'params' => [
'id' => $invitation->id,
],
],
],
]),
'created_at' => now(),
'updated_at' => now(),
]);
$this
->actingAs($member)
->deleteJson("/api/teams/invitations/{$invitation->id}")
->assertNoContent();
// Get notification
$notification = json_decode(DB::table('notifications')->first()->data);
// Check if action is null
$this->assertEquals(null, $notification->action);
$this
->assertDatabaseHas('team_folder_invitations', [
'parent_id' => $folder->id,
'status' => 'rejected',
])
->assertDatabaseMissing('team_folder_members', [
'parent_id' => $folder->id,
'user_id' => $member->id,
]);
}
/**
* @test
*/
public function it_invite_member_into_team_folder()
{
[$user, $member_1, $member_2] = User::factory()
->hasSettings()
->count(3)
->create();
$folder = Folder::factory()
->create([
'user_id' => $user->id,
'team_folder' => 1,
]);
TeamFolderInvitation::factory()
->create([
'parent_id' => $folder->id,
'status' => 'pending',
'permission' => 'can-edit',
'email' => 'existing@member.com',
]);
DB::table('team_folder_members')
->insert([
[
'parent_id' => $folder->id,
'user_id' => $member_1->id,
'permission' => 'can-edit',
],
[
'parent_id' => $folder->id,
'user_id' => $member_2->id,
'permission' => 'can-edit',
],
]);
$this
->actingAs($user)
->patchJson("/api/teams/folders/{$folder->id}", [
'members' => [
[
'id' => $member_1->id,
'permission' => 'can-edit',
],
[
'id' => $member_2->id,
'permission' => 'can-edit',
],
],
'invitations' => [
[
'id' => null,
'email' => 'existing@member.com',
'permission' => 'can-edit',
],
[
'id' => null,
'email' => 'added@member.com',
'permission' => 'can-view',
],
],
])
->assertCreated();
$this
->assertDatabaseCount('team_folder_members', 2)
->assertDatabaseCount('team_folder_invitations', 2)
->assertDatabaseHas('team_folder_invitations', [
'email' => 'added@member.com',
'permission' => 'can-view',
]);
Notification::assertTimesSent(1, InvitationIntoTeamFolder::class);
}
/**
* @test
*/
public function it_delete_invited_member_from_team_folder()
{
[$user, $member_1, $member_2] = User::factory()
->hasSettings()
->count(3)
->create();
$folder = Folder::factory()
->create([
'user_id' => $user->id,
'team_folder' => 1,
]);
TeamFolderInvitation::factory()
->create([
'parent_id' => $folder->id,
'status' => 'pending',
'permission' => 'can-edit',
'email' => 'deleted@member.com',
]);
TeamFolderInvitation::factory()
->create([
'parent_id' => $folder->id,
'status' => 'pending',
'permission' => 'can-edit',
'email' => 'existing@member.com',
]);
DB::table('team_folder_members')
->insert([
[
'parent_id' => $folder->id,
'user_id' => $member_1->id,
'permission' => 'can-edit',
],
[
'parent_id' => $folder->id,
'user_id' => $member_2->id,
'permission' => 'can-edit',
],
]);
$this
->actingAs($user)
->patchJson("/api/teams/folders/{$folder->id}", [
'members' => [
[
'id' => $member_1->id,
'permission' => 'can-edit',
],
[
'id' => $member_2->id,
'permission' => 'can-view',
],
],
'invitations' => [
[
'id' => null,
'email' => 'existing@member.com',
'permission' => 'can-view',
],
],
])
->assertCreated();
$this
->assertDatabaseCount('team_folder_members', 2)
->assertDatabaseCount('team_folder_invitations', 1)
->assertDatabaseHas('team_folder_invitations', [
'email' => 'existing@member.com',
]);
}
/**
* @test
*/
public function it_remove_member_from_team_folder()
{
[$user, $member, $deletedMember] = User::factory()
->hasSettings()
->count(3)
->create();
$folder = Folder::factory()
->create([
'user_id' => $user->id,
'team_folder' => 1,
]);
// Attach members to the team folder
DB::table('team_folder_members')
->insert([
[
'parent_id' => $folder->id,
'user_id' => $member->id,
'permission' => 'can-edit',
],
[
'parent_id' => $folder->id,
'user_id' => $deletedMember->id,
'permission' => 'can-edit',
],
]);
// Update team folder members
$this
->actingAs($user)
->patchJson("/api/teams/folders/{$folder->id}", [
'members' => [
[
'id' => $member->id,
'permission' => 'can-edit',
],
],
'invitations' => [],
])
->assertCreated();
$this
->assertDatabaseCount('team_folder_members', 1)
->assertDatabaseMissing('team_folder_members', [
'user_id' => $deletedMember->id,
]);
}
/**
* @test
*/
public function it_update_invited_member_permission_in_team_folder()
{
$user = User::factory()
->hasSettings()
->create();
$folder = Folder::factory()
->create([
'user_id' => $user->id,
'team_folder' => 1,
]);
TeamFolderInvitation::factory()
->create([
'parent_id' => $folder->id,
'status' => 'pending',
'permission' => 'can-view',
'email' => 'existing@member.com',
]);
$this
->actingAs($user)
->patchJson("/api/teams/folders/{$folder->id}", [
'members' => [],
'invitations' => [
[
'id' => null,
'email' => 'existing@member.com',
'permission' => 'can-edit',
],
],
])
->assertCreated();
$this
->assertDatabaseCount('team_folder_members', 0)
->assertDatabaseCount('team_folder_invitations', 1)
->assertDatabaseHas('team_folder_invitations', [
'email' => 'existing@member.com',
'permission' => 'can-edit',
]);
Notification::assertTimesSent(0, InvitationIntoTeamFolder::class);
}
/**
* @test
*/
public function it_update_member_permission_in_team_folder()
{
[$user, $member_1, $member_2] = User::factory()
->hasSettings()
->count(3)
->create();
$folder = Folder::factory()
->create([
'user_id' => $user->id,
'team_folder' => 1,
]);
DB::table('team_folder_members')
->insert([
[
'parent_id' => $folder->id,
'user_id' => $member_1->id,
'permission' => 'can-edit',
],
[
'parent_id' => $folder->id,
'user_id' => $member_2->id,
'permission' => 'can-edit',
],
]);
$this
->actingAs($user)
->patchJson("/api/teams/folders/{$folder->id}", [
'members' => [
[
'id' => $member_1->id,
'permission' => 'can-edit',
],
[
'id' => $member_2->id,
'permission' => 'can-view',
],
],
'invitations' => [],
])
->assertCreated();
$this->assertDatabaseHas('team_folder_members', [
'user_id' => $member_2->id,
'permission' => 'can-view',
]);
}
/**
* @test
*/
public function member_try_update_permission_in_team_folder()
{
[$user, $member_1, $member_2] = User::factory()
->count(3)
->create();
$folder = Folder::factory()
->create([
'user_id' => $user->id,
'team_folder' => 1,
]);
DB::table('team_folder_members')
->insert([
[
'parent_id' => $folder->id,
'user_id' => $member_1->id,
'permission' => 'can-edit',
],
[
'parent_id' => $folder->id,
'user_id' => $member_2->id,
'permission' => 'can-edit',
],
]);
$this
->actingAs(
User::find($member_1->id)
)
->patchJson("/api/teams/folders/{$folder->id}", [
'members' => [
[
'id' => $member_1->id,
'permission' => 'can-edit',
],
[
'id' => $member_2->id,
'permission' => 'can-view',
],
],
'invitations' => [],
])
->assertForbidden();
$this->assertDatabaseHas('team_folder_members', [
'user_id' => $member_2->id,
'permission' => 'can-edit',
]);
}
/**
* @test
*/
public function it_dissolve_team_folder()
{
[$user, $member_1, $member_2] = User::factory()
->count(3)
->create();
$folder = Folder::factory()
->create([
'user_id' => $user->id,
'team_folder' => 1,
]);
$folderWithin = Folder::factory()
->create([
'parent_id' => $folder->id,
'user_id' => $user->id,
'team_folder' => 1,
]);
TeamFolderInvitation::factory()
->create([
'parent_id' => $folder->id,
'status' => 'pending',
'permission' => 'can-edit',
]);
DB::table('team_folder_members')
->insert([
[
'parent_id' => $folder->id,
'user_id' => $member_1->id,
'permission' => 'can-edit',
],
[
'parent_id' => $folder->id,
'user_id' => $member_2->id,
'permission' => 'can-edit',
],
]);
$this
->actingAs($user)
->deleteJson("/api/teams/folders/{$folder->id}")
->assertNoContent();
$this
->assertDatabaseCount('team_folder_members', 0)
->assertDatabaseCount('team_folder_invitations', 0)
->assertDatabaseHas('folders', [
'id' => $folder->id,
'team_folder' => 0,
])
->assertDatabaseHas('folders', [
'id' => $folderWithin->id,
'team_folder' => 0,
]);
}
/**
* @test
*/
public function it_leave_team_folder()
{
[$user, $member] = User::factory()
->count(2)
->create();
$folder = Folder::factory()
->create([
'name' => 'Team Folder',
'user_id' => $user->id,
'team_folder' => 1,
]);
// add member to the team folder
DB::table('team_folder_members')
->insert([
[
'parent_id' => $folder->id,
'user_id' => $member->id,
'permission' => 'can-edit',
],
]);
$this
->actingAs($member)
->deleteJson("/api/teams/folders/{$folder->id}/leave")
->assertNoContent();
$this
->assertDatabaseMissing('team_folder_members', [
'parent_id' => $folder->id,
'user_id' => $member->id,
'permission' => 'can-edit',
]);
}
/**
* @test
*/
public function member_try_dissolve_team_folder()
{
[$user, $member_1, $member_2] = User::factory()
->count(3)
->create();
$folder = Folder::factory()
->create([
'user_id' => $user->id,
'team_folder' => 1,
]);
TeamFolderInvitation::factory()
->create([
'parent_id' => $folder->id,
'status' => 'pending',
'permission' => 'can-edit',
]);
DB::table('team_folder_members')
->insert([
[
'parent_id' => $folder->id,
'user_id' => $member_1->id,
'permission' => 'can-edit',
],
[
'parent_id' => $folder->id,
'user_id' => $member_2->id,
'permission' => 'can-edit',
],
]);
$this
->actingAs(
User::find($member_1->id)
)
->deleteJson("/api/teams/folders/{$folder->id}")
->assertForbidden();
$this
->assertDatabaseCount('team_folder_members', 2)
->assertDatabaseCount('team_folder_invitations', 1);
}
}
tests/Domain/Teams/TeamsTest.php
-299
View File
@@ -1,299 +0,0 @@
<?php
namespace Tests\Domain\Teams;
use Notification;
use Tests\TestCase;
use App\Users\Models\User;
use Domain\Files\Models\File;
use Domain\Folders\Models\Folder;
use Illuminate\Http\UploadedFile;
use Illuminate\Support\Facades\DB;
use Domain\Teams\Notifications\InvitationIntoTeamFolder;
class TeamsTest extends TestCase
{
/**
* @test
*/
public function it_find_team_parent_id_from_children()
{
$teamFolder = Folder::factory()
->create([
'team_folder' => 1,
]);
$level_1 = Folder::factory()
->create([
'parent_id' => $teamFolder->id,
]);
$level_2 = Folder::factory()
->create([
'parent_id' => $level_1->id,
]);
$this->assertEquals($teamFolder->id, $level_2->getLatestParent()->id);
$this->assertEquals($teamFolder->id, $teamFolder->getLatestParent()->id);
}
/**
* @test
*/
public function it_create_team_folder()
{
User::factory()
->create([
'email' => 'john@internal.com',
]);
$user = User::factory()
->hasSettings()
->create();
$this
->actingAs($user)
->post('/api/teams/folders', [
'name' => 'Company Project',
'invitations' => [
[
'email' => 'john@internal.com',
'permission' => 'can-edit',
],
[
'email' => 'jane@external.com',
'permission' => 'can-view',
],
],
])
->assertCreated()
->assertJsonFragment([
'name' => 'Company Project',
]);
$this
->assertDatabaseHas('folders', [
'user_id' => $user->id,
'name' => 'Company Project',
'team_folder' => 1,
])
->assertDatabaseHas('team_folder_invitations', [
'email' => 'john@internal.com',
])
->assertDatabaseHas('team_folder_invitations', [
'email' => 'jane@external.com',
]);
Notification::assertTimesSent(2, InvitationIntoTeamFolder::class);
}
/**
* @test
*/
public function it_mark_newly_created_folder_as_team_folder()
{
$user = User::factory()
->hasSettings()
->create();
$teamFolder = Folder::factory()
->create([
'user_id' => $user->id,
'team_folder' => 1,
]);
$this
->actingAs($user)
->postJson('/api/create-folder', [
'name' => 'Inner Folder',
'parent_id' => $teamFolder->id,
])
->assertStatus(201)
->assertJsonFragment([
'isTeamFolder' => true,
'id' => $user->id,
]);
}
/**
* @test
*/
public function it_convert_folder_into_team_folder()
{
$user = User::factory()
->hasSettings()
->create();
$folder = Folder::factory()
->create([
'user_id' => $user->id,
]);
$folderWithin = Folder::factory()
->create([
'parent_id' => $folder->id,
'user_id' => $user->id,
]);
$this
->actingAs($user)
->post("/api/teams/folders/{$folder->id}/convert", [
'invitations' => [
[
'email' => 'john@internal.com',
'permission' => 'can-edit',
],
[
'email' => 'jane@external.com',
'permission' => 'can-view',
],
],
])
->assertCreated()
->assertJsonFragment([
'name' => $folder->name,
]);
$this->assertDatabaseHas('folders', [
'id' => $folderWithin->id,
'team_folder' => 1,
]);
Notification::assertTimesSent(2, InvitationIntoTeamFolder::class);
}
/**
* @test
*/
public function it_get_all_team_folders()
{
$user = User::factory()
->hasSettings()
->create();
$folder = Folder::factory()
->create([
'user_id' => $user->id,
'team_folder' => 1,
]);
$this
->actingAs($user)
->getJson('/api/teams/folders/undefined')
->assertOk()
->assertJsonFragment([
'id' => $folder->id,
]);
}
/**
* @test
*/
public function it_get_content_of_team_folder()
{
$user = User::factory()
->hasSettings()
->create();
$folder = Folder::factory()
->create([
'user_id' => $user->id,
'team_folder' => 1,
]);
$file = File::factory()
->create([
'parent_id' => $folder->id,
'user_id' => $user->id,
]);
$this
->actingAs($user)
->getJson("/api/teams/folders/{$folder->id}")
->assertOk()
->assertJsonFragment([
'id' => $file->id,
]);
}
/**
* @test
*/
public function it_get_team_folders_shared_with_another_user()
{
$user = User::factory()
->hasSettings()
->create();
$member = User::factory()
->hasSettings()
->create();
$folders = Folder::factory()
->count(2)
->create([
'user_id' => $user->id,
'team_folder' => 1,
]);
DB::table('team_folder_members')
->insert([
[
'parent_id' => $folders[0]->id,
'user_id' => $member->id,
'permission' => 'can-edit',
],
[
'parent_id' => $folders[1]->id,
'user_id' => $member->id,
'permission' => 'can-edit',
],
]);
$this
->actingAs($member)
->getJson('/api/teams/shared-with-me/undefined')
->assertOk()
->assertJsonFragment([
'id' => $folders[0]->id,
]);
}
/**
* @test
*/
public function team_member_upload_new_file()
{
$file = UploadedFile::fake()
->create('fake-file.pdf', 12000000, 'application/pdf');
$user = User::factory()
->hasSettings()
->create();
$member = User::factory()
->hasSettings()
->create();
$folder = Folder::factory()
->create([
'user_id' => $user->id,
'team_folder' => 1,
]);
$this
->actingAs($member)
->postJson('/api/upload', [
'name' => $file->name,
'extension' => 'pdf',
'file' => $file,
'parent_id' => $folder->id,
'path' => "/$file->name",
'is_last' => 'true',
])->assertStatus(201);
$this->assertDatabaseHas('files', [
'user_id' => $user->id,
'creator_id' => $member->id,
]);
}
}
tests/Domain/UploadRequest/UploadRequestAccessTest.php
-112
View File
@@ -1,112 +0,0 @@
<?php
namespace Tests\Domain\UploadRequest;
use Storage;
use Tests\TestCase;
use App\Users\Models\User;
use Illuminate\Support\Str;
use Domain\Files\Models\File;
use Illuminate\Http\UploadedFile;
use Domain\UploadRequest\Models\UploadRequest;
class UploadRequestAccessTest extends TestCase
{
/**
* @test
*/
public function it_get_file_from_upload_request_folder()
{
$user = User::factory()
->hasSettings()
->create();
$uploadRequest = UploadRequest::factory()
->create([
'status' => 'active',
'user_id' => $user->id,
'created_at' => now(),
]);
$file = UploadedFile::fake()
->create(Str::random() . '-fake-file.pdf', 1200, 'application/pdf');
Storage::putFileAs("files/$user->id", $file, $file->name);
File::factory()
->create([
'parent_id' => $uploadRequest->id,
'basename' => $file->name,
'user_id' => $user->id,
'name' => $file->name,
]);
$this
->get("/file/$file->name/upload-request/$uploadRequest->id")
->assertDownload($file->name);
}
/**
* @test
*/
public function it_get_thumbnail_from_upload_request_folder()
{
$user = User::factory()
->hasSettings()
->create();
$uploadRequest = UploadRequest::factory()
->create([
'status' => 'active',
'user_id' => $user->id,
'created_at' => now(),
]);
$thumbnail = UploadedFile::fake()
->image('fake-thumbnail.jpg');
Storage::putFileAs("files/$user->id", $thumbnail, $thumbnail->name);
File::factory()
->create([
'parent_id' => $uploadRequest->id,
'basename' => 'fake-thumbnail.jpg',
'user_id' => $user->id,
]);
$this
->get("/thumbnail/xs-$thumbnail->name/upload-request/$uploadRequest->id")
->assertDownload("xs-$thumbnail->name");
}
/**
* @test
*/
public function it_try_get_file_from_expired_upload_request_folder()
{
$uploadRequest = UploadRequest::factory()
->create([
'status' => 'expired',
'created_at' => now(),
]);
$this
->get("/file/fake-file.pdf/upload-request/$uploadRequest->id")
->assertStatus(410);
}
/**
* @test
*/
public function it_try_get_thumbnail_from_expired_upload_request_folder()
{
$uploadRequest = UploadRequest::factory()
->create([
'status' => 'filled',
'created_at' => now(),
]);
$this
->get("/thumbnail/xs-fake-thumbnail.jpeg/upload-request/$uploadRequest->id")
->assertStatus(410);
}
}
tests/Domain/UploadRequest/UploadRequestBrowsingTest.php
-180
View File
@@ -1,180 +0,0 @@
<?php
namespace Tests\Domain\UploadRequest;
use Tests\TestCase;
use App\Users\Models\User;
use Domain\Files\Models\File;
use Domain\Folders\Models\Folder;
use Domain\UploadRequest\Models\UploadRequest;
class UploadRequestBrowsingTest extends TestCase
{
/**
* @test
*/
public function it_get_navigator_tree_for_upload_request_folder()
{
$user = User::factory()
->hasSettings()
->create();
$uploadRequest = UploadRequest::factory()
->create([
'status' => 'active',
'user_id' => $user->id,
]);
Folder::factory()
->create([
'id' => $uploadRequest->id,
'name' => 'Upload request',
'user_id' => $user->id,
]);
$folder_level_1 = Folder::factory()
->create([
'parent_id' => $uploadRequest->id,
'name' => 'level 1',
'user_id' => $user->id,
]);
$folder_level_2 = Folder::factory()
->create([
'name' => 'level 2',
'parent_id' => $folder_level_1->id,
'user_id' => $user->id,
]);
$this
->actingAs($user)
->getJson("/api/upload-request/$uploadRequest->id/navigation")
->assertStatus(200)
->assertExactJson([
[
'location' => 'upload-request',
'name' => 'Upload Request',
'folders' => [
[
'id' => $folder_level_1->id,
'parent_id' => $uploadRequest->id,
'name' => 'level 1',
'items' => 1,
'trashed_items' => 1,
'folders' => [
[
'id' => $folder_level_2->id,
'parent_id' => $folder_level_1->id,
'name' => 'level 2',
'items' => 0,
'trashed_items' => 0,
'folders' => [],
],
],
],
],
'isMovable' => true,
'isOpen' => true,
],
]);
}
/**
* @test
*/
public function it_get_folder_content_for_upload_request_folder()
{
$user = User::factory()
->hasSettings()
->create();
$uploadRequest = UploadRequest::factory()
->create([
'status' => 'active',
'user_id' => $user->id,
]);
$root = Folder::factory()
->create([
'id' => $uploadRequest->id,
'name' => 'root',
'user_id' => $user->id,
]);
$folder = Folder::factory()
->create([
'parent_id' => $root->id,
'author' => 'user',
'user_id' => $user->id,
]);
$file = File::factory()
->create([
'parent_id' => $root->id,
'user_id' => $user->id,
]);
$this
->actingAs($user)
->getJson("/api/upload-request/$uploadRequest->id/browse/$root->id")
->assertStatus(200)
->assertJsonFragment([
'id' => $root->id,
])
->assertJsonFragment([
'id' => $file->id,
])
->assertJsonFragment([
'id' => $folder->id,
]);
}
/**
* @test
*/
public function it_get_folder_content_from_not_existed_upload_request_folder()
{
$user = User::factory()
->hasSettings()
->create();
$uploadRequest = UploadRequest::factory()
->create([
'status' => 'active',
'user_id' => $user->id,
]);
$root = Folder::factory()
->create([
'id' => $uploadRequest->id,
'name' => 'root',
'user_id' => $user->id,
]);
$folder = Folder::factory()
->create([
'parent_id' => $root->id,
'author' => 'user',
'user_id' => $user->id,
]);
$file = File::factory()
->create([
'parent_id' => $root->id,
'user_id' => $user->id,
]);
$this
->actingAs($user)
->getJson("/api/upload-request/$uploadRequest->id/browse/$root->id")
->assertStatus(200)
->assertJsonFragment([
'id' => $root->id,
])
->assertJsonFragment([
'id' => $file->id,
])
->assertJsonFragment([
'id' => $folder->id,
]);
}
}
tests/Domain/UploadRequest/UploadRequestEditingTest.php
-335
View File
@@ -1,335 +0,0 @@
<?php
namespace Tests\Domain\UploadRequest;
use Storage;
use Tests\TestCase;
use App\Users\Models\User;
use Domain\Files\Models\File;
use Domain\Folders\Models\Folder;
use Illuminate\Http\UploadedFile;
use Domain\UploadRequest\Models\UploadRequest;
class UploadRequestEditingTest extends TestCase
{
/**
* @test
*/
public function it_rename_folder_item()
{
$user = User::factory()
->hasSettings()
->create();
$uploadRequest = UploadRequest::factory()
->create([
'status' => 'active',
'user_id' => $user->id,
]);
$folder = Folder::factory()
->create([
'parent_id' => $uploadRequest->id,
'user_id' => $user->id,
]);
$this
->actingAs($user)
->patchJson("/api/upload-request/$uploadRequest->id/rename/$folder->id", [
'name' => 'Renamed Folder',
'type' => 'folder',
])
->assertStatus(200)
->assertJsonFragment([
'name' => 'Renamed Folder',
]);
$this->assertDatabaseHas('folders', [
'name' => 'Renamed Folder',
]);
}
/**
* @test
*/
public function it_rename_file_item()
{
$user = User::factory()
->hasSettings()
->create();
$uploadRequest = UploadRequest::factory()
->create([
'status' => 'active',
'user_id' => $user->id,
]);
$file = File::factory()
->create([
'parent_id' => $uploadRequest->id,
'user_id' => $user->id,
]);
$this
->actingAs($user)
->patchJson("/api/upload-request/$uploadRequest->id/rename/$file->id", [
'name' => 'Renamed File',
'type' => 'file',
])
->assertStatus(200)
->assertJsonFragment([
'name' => 'Renamed File',
]);
$this->assertDatabaseHas('files', [
'name' => 'Renamed File',
]);
}
/**
* @test
*/
public function it_create_new_folder_in_upload_request()
{
$user = User::factory()
->hasSettings()
->create();
$uploadRequest = UploadRequest::factory()
->create([
'status' => 'active',
'user_id' => $user->id,
]);
$this
->actingAs($user)
->postJson("/api/upload-request/$uploadRequest->id/create-folder", [
'name' => 'New Folder',
'parent_id' => $uploadRequest->id,
])
->assertStatus(201)
->assertJsonFragment([
'name' => 'New Folder',
]);
$this->assertDatabaseHas('folders', [
'name' => 'New Folder',
'parent_id' => $uploadRequest->id,
]);
}
/**
* @test
*/
public function it_delete_image_with_their_thumbnails()
{
$user = User::factory()
->hasSettings()
->create();
$uploadRequest = UploadRequest::factory()
->create([
'status' => 'active',
'user_id' => $user->id,
]);
$image = File::factory()
->create([
'mimetype' => 'jpeg',
'type' => 'image',
'basename' => 'fake-image.jpeg',
'user_id' => $user->id,
'parent_id' => $uploadRequest->id,
]);
// Mock files
$thumbnail_sizes = collect([
config('vuefilemanager.image_sizes.later'),
config('vuefilemanager.image_sizes.immediately'),
])->collapse();
$fakeFile = UploadedFile::fake()
->create('fake-image.jpeg', 2000, 'image/jpeg');
Storage::putFileAs("files/$user->id", $fakeFile, $fakeFile->name);
// Create fake image thumbnails
$thumbnail_sizes
->each(function ($item) use ($user) {
$fakeFile = UploadedFile::fake()
->create("{$item['name']}-fake-image.jpeg", 2000, 'image/jpeg');
Storage::putFileAs("files/$user->id", $fakeFile, $fakeFile->name);
});
$this
->postJson("/api/upload-request/$uploadRequest->id/remove", [
'items' => [
[
'id' => $image->id,
'type' => 'file',
'force_delete' => true,
],
],
])->assertStatus(204);
// Assert primary file was deleted
Storage::assertMissing("files/$user->id/fake-image.jpeg");
// Assert thumbnail was deleted
getThumbnailFileList('fake-image.jpeg')
->each(fn ($thumbnail) => Storage::assertMissing("files/$user->id/$thumbnail"));
}
/**
* @test
*/
public function it_delete_file()
{
$user = User::factory()
->hasSettings()
->create();
$uploadRequest = UploadRequest::factory()
->create([
'status' => 'active',
'user_id' => $user->id,
]);
$file = File::factory()
->create([
'type' => 'file',
'basename' => 'fake-file.pdf',
'user_id' => $user->id,
'parent_id' => $uploadRequest->id,
]);
$fakeFile = UploadedFile::fake()
->create('fake-file.pdf', 1200, 'application/pdf');
Storage::putFileAs("files/$user->id", $fakeFile, $fakeFile->name);
$this
->postJson("/api/upload-request/$uploadRequest->id/remove", [
'items' => [
[
'id' => $file->id,
'type' => 'file',
'force_delete' => true,
],
],
])->assertStatus(204);
// Assert primary file was deleted
Storage::assertMissing("files/$user->id/fake-file.pdf");
}
/**
* @test
*/
public function it_delete_folder_with_file_within()
{
$user = User::factory()
->hasSettings()
->create();
$uploadRequest = UploadRequest::factory()
->create([
'status' => 'active',
'user_id' => $user->id,
]);
$folder = Folder::factory()
->create([
'user_id' => $user->id,
'parent_id' => $uploadRequest->id,
]);
$folderWithin = Folder::factory()
->create([
'user_id' => $user->id,
'parent_id' => $folder->id,
]);
$file = File::factory()
->create([
'type' => 'file',
'basename' => 'fake-file.pdf',
'user_id' => $user->id,
'parent_id' => $folder->id,
]);
$fakeFile = UploadedFile::fake()
->create('fake-file.pdf', 1200, 'application/pdf');
Storage::putFileAs("files/$user->id", $fakeFile, $fakeFile->name);
$this
->postJson("/api/upload-request/$uploadRequest->id/remove", [
'items' => [
[
'id' => $folder->id,
'type' => 'folder',
'force_delete' => true,
],
],
])->assertStatus(204);
$this
->assertDatabaseMissing('folders', [
'id' => $folder->id,
])
->assertDatabaseMissing('folders', [
'id' => $folderWithin->id,
])
->assertDatabaseMissing('files', [
'id' => $file->id,
]);
// Assert primary file was deleted
Storage::assertMissing("files/$user->id/fake-file.pdf");
}
/**
* @test
*/
public function it_move_file_to_another_folder_in_upload_request()
{
$user = User::factory()
->hasSettings()
->create();
$uploadRequest = UploadRequest::factory()
->create([
'status' => 'active',
'user_id' => $user->id,
]);
$folder = Folder::factory()
->create([
'id' => $uploadRequest->id,
'user_id' => $user->id,
]);
$file = File::factory()
->create([
'parent_id' => $uploadRequest->id,
'user_id' => $user->id,
]);
$this
->postJson("/api/upload-request/$uploadRequest->id/move", [
'to_id' => $folder->id,
'items' => [
[
'type' => 'file',
'id' => $file->id,
],
],
])->assertStatus(204);
$this->assertDatabaseHas('files', [
'id' => $file->id,
'parent_id' => $folder->id,
]);
}
}
tests/Domain/UploadRequest/UploadRequestTest.php
-333
View File
@@ -1,333 +0,0 @@
<?php
namespace Tests\Domain\UploadRequest;
use Storage;
use Notification;
use Tests\TestCase;
use App\Users\Models\User;
use Domain\Files\Models\File;
use Illuminate\Http\UploadedFile;
use Domain\UploadRequest\Models\UploadRequest;
use Support\Scheduler\Actions\ExpireUnfilledUploadRequestAction;
use Domain\UploadRequest\Notifications\UploadRequestNotification;
use Domain\UploadRequest\Notifications\UploadRequestFulfilledNotification;
class UploadRequestTest extends TestCase
{
/**
* @test
*/
public function it_test_upload_request_factory()
{
$uploadRequest = UploadRequest::factory()
->create();
$this->assertModelExists($uploadRequest);
}
/**
* @test
*/
public function user_create_upload_request_with_email()
{
$user = User::factory()
->hasSettings()
->create();
$this
->actingAs($user)
->postJson('/api/upload-request', [
'folder_id' => '00cacdb9-1d09-4a32-8ad7-c0d45d66b758',
'email' => 'howdy@hi5ve.digital',
'notes' => 'Please send me your files...',
])
->assertCreated();
$this->assertDatabasehas('upload_requests', [
'folder_id' => '00cacdb9-1d09-4a32-8ad7-c0d45d66b758',
'email' => 'howdy@hi5ve.digital',
'notes' => 'Please send me your files...',
]);
Notification::assertTimesSent(1, UploadRequestNotification::class);
}
/**
* @test
*/
public function user_create_upload_request_without_email()
{
$user = User::factory()
->hasSettings()
->create();
$this
->actingAs($user)
->postJson('/api/upload-request', [
'folder_id' => '00cacdb9-1d09-4a32-8ad7-c0d45d66b758',
'notes' => 'Please send me your files...',
])
->assertCreated();
$this->assertDatabasehas('upload_requests', [
'folder_id' => '00cacdb9-1d09-4a32-8ad7-c0d45d66b758',
'notes' => 'Please send me your files...',
'email' => null,
]);
Notification::assertNothingSent();
}
/**
* @test
*/
public function user_create_upload_request_with_name()
{
$user = User::factory()
->hasSettings()
->create();
$this
->actingAs($user)
->postJson('/api/upload-request', [
'folder_id' => '00cacdb9-1d09-4a32-8ad7-c0d45d66b758',
'notes' => 'Please send me your files...',
'name' => 'My name',
])
->assertCreated();
$this->assertDatabasehas('upload_requests', [
'folder_id' => '00cacdb9-1d09-4a32-8ad7-c0d45d66b758',
'notes' => 'Please send me your files...',
'email' => null,
'name' => 'My name',
]);
Notification::assertNothingSent();
}
/**
* @test
*/
public function it_get_upload_request_detail()
{
$user = User::factory()
->hasSettings()
->create();
$uploadRequest = UploadRequest::factory()
->create([
'status' => 'active',
'user_id' => $user->id,
]);
$this->getJson("/api/upload-request/$uploadRequest->id")
->assertOk()
->assertJsonFragment([
'id' => $uploadRequest->id,
]);
}
/**
* @test
*/
public function it_upload_file_and_create_upload_request_folder_without_custom_folder_name()
{
$user = User::factory()
->hasSettings()
->create();
$uploadRequest = UploadRequest::factory()
->create([
'status' => 'active',
'user_id' => $user->id,
'created_at' => now(),
'name' => null,
]);
$file = UploadedFile::fake()
->create('fake-file.pdf', 12000000, 'application/pdf');
$this
->postJson("/api/upload-request/$uploadRequest->id/upload", [
'name' => $file->name,
'extension' => 'pdf',
'file' => $file,
'parent_id' => null,
'path' => "/$file->name",
'is_last' => 'true',
])->assertStatus(201);
$this
->assertDatabaseHas('upload_requests', [
'status' => 'filling',
])
->assertDatabaseHas('folders', [
'id' => $uploadRequest->id,
'name' => 'Upload Request from 01. Jan. 2021',
])->assertDatabaseHas('files', [
'parent_id' => $uploadRequest->id,
]);
$file = File::first();
Storage::assertExists("files/$user->id/$file->basename");
}
/**
* @test
*/
public function it_upload_file_and_create_upload_request_folder_with_custom_folder_name()
{
$user = User::factory()
->hasSettings()
->create();
$uploadRequest = UploadRequest::factory()
->create([
'status' => 'active',
'user_id' => $user->id,
'created_at' => now(),
'name' => 'My Documents',
]);
$file = UploadedFile::fake()
->create('fake-file.pdf', 12000000, 'application/pdf');
$this
->postJson("/api/upload-request/$uploadRequest->id/upload", [
'name' => $file->name,
'extension' => 'pdf',
'file' => $file,
'parent_id' => null,
'path' => "/$file->name",
'is_last' => 'true',
])->assertStatus(201);
$this
->assertDatabaseHas('upload_requests', [
'status' => 'filling',
])
->assertDatabaseHas('folders', [
'id' => $uploadRequest->id,
'name' => 'My Documents',
])->assertDatabaseHas('files', [
'parent_id' => $uploadRequest->id,
]);
$file = File::first();
Storage::assertExists("files/$user->id/$file->basename");
}
/**
* @test
*/
public function it_try_upload_file_into_non_active_upload_request()
{
$user = User::factory()
->hasSettings()
->create();
$uploadRequest = UploadRequest::factory()
->create([
'status' => 'expired',
'user_id' => $user->id,
'created_at' => now(),
]);
$file = UploadedFile::fake()
->create('fake-file.pdf', 12000000, 'application/pdf');
$this
->postJson("/api/upload-request/$uploadRequest->id/upload", [
'name' => $file->name,
'file' => $file,
'parent_id' => null,
'path' => "/$file->name",
'is_last' => 'true',
])->assertStatus(410);
}
/**
* @test
*/
public function it_mark_upload_request_as_filled()
{
$user = User::factory()
->hasSettings()
->create();
$uploadRequest = UploadRequest::factory()
->create([
'status' => 'active',
'user_id' => $user->id,
]);
$this
->deleteJson("/api/upload-request/$uploadRequest->id")
->assertStatus(201)
->assertJsonFragment([
'id' => $uploadRequest->id,
'status' => 'filled',
]);
Notification::assertSentTo($user, UploadRequestFulfilledNotification::class);
}
/**
* @test
*/
public function it_mark_upload_request_as_expired_after_72_hours()
{
UploadRequest::factory()
->create([
'status' => 'active',
'created_at' => now()->subHours(72),
]);
resolve(ExpireUnfilledUploadRequestAction::class)();
$this->assertDatabaseHas('upload_requests', [
'status' => 'expired',
]);
}
/**
* @test
*/
public function it_mark_upload_request_as_filled_3_hours_after_last_upload()
{
$user = User::factory()
->hasSettings()
->create();
$uploadRequest = UploadRequest::factory()
->create([
'status' => 'active',
'user_id' => $user->id,
'created_at' => now(),
]);
$file = UploadedFile::fake()
->create('fake-file.pdf', 12000000, 'application/pdf');
$this
->postJson("/api/upload-request/$uploadRequest->id/upload", [
'name' => $file->name,
'extension' => 'pdf',
'file' => $file,
'parent_id' => null,
'path' => "/$file->name",
'is_last' => 'true',
])->assertCreated();
$this->travel(3)->hours();
resolve(ExpireUnfilledUploadRequestAction::class)();
$this->assertDatabaseHas('upload_requests', [
'status' => 'filled',
]);
}
}