nexus/vuefilemanager
2
0
Fork 0
mirror of https://github.com/VueFileManager/vuefilemanager.git synced 2026-05-25 14:14:42 +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);
}
}