cf5b300895
- Updated the OwnerVerificationRequest model to change pendingToggleIsActive to pendingToggleStatus, reflecting the new status structure. - Refactored the Product model to replace is_active with status, utilizing the ProductStatus enum for better clarity and type safety. - Modified the ProductService to accommodate the new status field, including pagination and creation logic. - Adjusted the AnalysisService to filter products based on their status. - Updated the VerificationChangeFormatter to handle the new status field. - Created a migration to remove is_active from the products table and add status with appropriate default values. - Refactored the ProductSeeder to use the new status field. - Updated frontend components and types to reflect the changes from is_active to status. - Adjusted tests to ensure they validate the new status logic correctly.
1214 lines
44 KiB
PHP
1214 lines
44 KiB
PHP
<?php
|
|
|
|
use App\Enums\OwnerVerificationAction;
|
|
use App\Enums\OwnerVerificationStatus;
|
|
use App\Enums\Permission as PermissionEnum;
|
|
use App\Enums\ProductStatus;
|
|
use App\Models\Category;
|
|
use App\Models\OwnerVerificationRequest;
|
|
use App\Models\Product;
|
|
use App\Models\ProductPrice;
|
|
use App\Models\ProductVariant;
|
|
use App\Models\User;
|
|
use Database\Seeders\RolePermissionSeeder;
|
|
use Illuminate\Foundation\Testing\RefreshDatabase;
|
|
use Illuminate\Http\UploadedFile;
|
|
use Illuminate\Support\Facades\Storage;
|
|
use Illuminate\Support\Str;
|
|
|
|
uses(RefreshDatabase::class);
|
|
|
|
beforeEach(function () {
|
|
$this->seed(RolePermissionSeeder::class);
|
|
Storage::fake('public');
|
|
});
|
|
|
|
// ─── Helper ───────────────────────────────────────────────
|
|
|
|
function createProductUserWithPermission(PermissionEnum ...$permissions): User
|
|
{
|
|
$user = User::factory()->create();
|
|
|
|
$user->givePermissionTo(
|
|
array_merge(
|
|
[PermissionEnum::DASHBOARD_VIEW->value],
|
|
array_map(fn (PermissionEnum $p) => $p->value, $permissions)
|
|
)
|
|
);
|
|
|
|
$user->forgetCachedPermissions();
|
|
|
|
return $user;
|
|
}
|
|
|
|
function createProductWithVariants(?Category $category = null): Product
|
|
{
|
|
$category ??= Category::factory()->create();
|
|
$product = Product::factory()->create();
|
|
$product->categories()->attach($category->id);
|
|
|
|
$variants = ProductVariant::factory()->count(2)->create(['product_id' => $product->id]);
|
|
|
|
foreach ($variants as $variant) {
|
|
$variant->addMedia(UploadedFile::fake()->image("{$variant->name}.jpg", 100, 100))
|
|
->toMediaCollection('images');
|
|
}
|
|
|
|
return $product;
|
|
}
|
|
|
|
function createProductVerifierUser(): User
|
|
{
|
|
$user = User::factory()->create();
|
|
|
|
$user->givePermissionTo([
|
|
PermissionEnum::DASHBOARD_VIEW->value,
|
|
PermissionEnum::OWNER_VERIFICATIONS_VIEW->value,
|
|
PermissionEnum::OWNER_VERIFICATIONS_VERIFY->value,
|
|
PermissionEnum::OWNER_VERIFICATIONS_REJECT->value,
|
|
]);
|
|
|
|
$user->forgetCachedPermissions();
|
|
|
|
return $user;
|
|
}
|
|
|
|
function variantWithImage(string $name = 'All Size', int $stock = 10): array
|
|
{
|
|
$disk = config('filesystems.default') === 's3' ? 's3' : config('filesystems.default', 'public');
|
|
$key = 'products/'.Str::uuid().'.jpg';
|
|
$imageContent = UploadedFile::fake()->image("{$name}.jpg", 100, 100)->get();
|
|
Storage::disk($disk)->put($key, $imageContent);
|
|
|
|
return [
|
|
'name' => $name,
|
|
'stock' => $stock,
|
|
'retail_stock' => 0,
|
|
's3_keys' => [$key],
|
|
'prices' => defaultPrices(),
|
|
];
|
|
}
|
|
|
|
function defaultPrices(): array
|
|
{
|
|
return [
|
|
'distributor' => 100000,
|
|
'agent' => 110000,
|
|
'sub_agent' => 120000,
|
|
'grosir' => 130000,
|
|
'retail' => 150000,
|
|
'tiktok' => 160000,
|
|
'shopee' => 165000,
|
|
'harga_modal' => 80000,
|
|
];
|
|
}
|
|
|
|
function variantUpdateData(int $id, string $name = 'Updated Variant', int $stock = 20): array
|
|
{
|
|
return [
|
|
'id' => $id,
|
|
'name' => $name,
|
|
'stock' => $stock,
|
|
'retail_stock' => 0,
|
|
'prices' => defaultPrices(),
|
|
];
|
|
}
|
|
|
|
// ─── Index ────────────────────────────────────────────────
|
|
|
|
describe('Product Index', function () {
|
|
test('authenticated user with permission can view product index', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW);
|
|
|
|
createProductWithVariants();
|
|
|
|
$this->actingAs($user)
|
|
->get(route('admin.master.products.index'))
|
|
->assertOk();
|
|
});
|
|
|
|
test('guest is redirected to login', function () {
|
|
$this->get(route('admin.master.products.index'))
|
|
->assertRedirect(route('login'));
|
|
});
|
|
|
|
test('user without permission is forbidden', function () {
|
|
$user = User::factory()->create();
|
|
|
|
$this->actingAs($user)
|
|
->get(route('admin.master.products.index'))
|
|
->assertForbidden();
|
|
});
|
|
|
|
test('index displays products with variants and categories', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW);
|
|
|
|
createProductWithVariants();
|
|
createProductWithVariants();
|
|
|
|
$this->actingAs($user)
|
|
->get(route('admin.master.products.index'))
|
|
->assertOk();
|
|
});
|
|
|
|
test('index can search products by name', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW);
|
|
|
|
$category = Category::factory()->create();
|
|
$product = Product::factory()->create(['name' => 'Batik Modern']);
|
|
$product->categories()->attach($category->id);
|
|
ProductVariant::factory()->create(['product_id' => $product->id]);
|
|
|
|
$this->actingAs($user)
|
|
->get(route('admin.master.products.index', ['search' => 'Batik']))
|
|
->assertOk();
|
|
});
|
|
|
|
test('index can search products by id', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW);
|
|
|
|
$category = Category::factory()->create();
|
|
$product1 = Product::factory()->create(['name' => 'Batik Modern']);
|
|
$product1->categories()->attach($category->id);
|
|
ProductVariant::factory()->create(['product_id' => $product1->id]);
|
|
|
|
$product2 = Product::factory()->create(['name' => 'Baju Sutra']);
|
|
$product2->categories()->attach($category->id);
|
|
ProductVariant::factory()->create(['product_id' => $product2->id]);
|
|
|
|
$response = $this->actingAs($user)
|
|
->get(route('admin.master.products.index', ['search_id' => $product1->id]));
|
|
|
|
$response->assertOk();
|
|
$response->assertInertia(fn ($page) => $page
|
|
->has('products.data', 1)
|
|
->where('products.data.0.id', $product1->id)
|
|
);
|
|
});
|
|
|
|
test('index can filter by active status', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW);
|
|
|
|
createProductWithVariants();
|
|
|
|
$this->actingAs($user)
|
|
->get(route('admin.master.products.index', ['status' => 'active']))
|
|
->assertOk();
|
|
});
|
|
|
|
test('index can filter by category', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW);
|
|
|
|
$category = Category::factory()->create();
|
|
createProductWithVariants($category);
|
|
|
|
$this->actingAs($user)
|
|
->get(route('admin.master.products.index', ['category_id' => $category->id]))
|
|
->assertOk();
|
|
});
|
|
});
|
|
|
|
// ─── Create ───────────────────────────────────────────────
|
|
|
|
describe('Product Create', function () {
|
|
test('authenticated user with permission can view create form', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW, PermissionEnum::PRODUCTS_CREATE);
|
|
|
|
$this->actingAs($user)
|
|
->get(route('admin.master.products.create'))
|
|
->assertOk();
|
|
});
|
|
|
|
test('guest is redirected to login', function () {
|
|
$this->get(route('admin.master.products.create'))
|
|
->assertRedirect(route('login'));
|
|
});
|
|
|
|
test('user without create permission is forbidden', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW);
|
|
|
|
$this->actingAs($user)
|
|
->get(route('admin.master.products.create'))
|
|
->assertForbidden();
|
|
});
|
|
});
|
|
|
|
// ─── Store ────────────────────────────────────────────────
|
|
|
|
describe('Product Store', function () {
|
|
test('authenticated user with permission can submit product creation request', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW, PermissionEnum::PRODUCTS_CREATE);
|
|
|
|
$category = Category::factory()->create();
|
|
|
|
$this->actingAs($user)
|
|
->post(route('admin.master.products.store'), [
|
|
'name' => 'Produk Baru',
|
|
'status' => 'active',
|
|
'description' => 'Deskripsi produk',
|
|
'category_ids' => [$category->id],
|
|
'variants' => [
|
|
variantWithImage('All Size', 10),
|
|
],
|
|
])
|
|
->assertRedirect(route('admin.master.products.index'));
|
|
|
|
$this->assertDatabaseHas('owner_verification_requests', [
|
|
'subject_type' => Product::class,
|
|
'action' => OwnerVerificationAction::CREATE->value,
|
|
'status' => OwnerVerificationStatus::PENDING->value,
|
|
]);
|
|
|
|
$this->assertDatabaseHas('products', [
|
|
'name' => 'Produk Baru',
|
|
'status' => ProductStatus::INACTIVE->value,
|
|
]);
|
|
});
|
|
|
|
test('guest cannot create a product', function () {
|
|
$category = Category::factory()->create();
|
|
|
|
$this->post(route('admin.master.products.store'), [
|
|
'name' => 'Produk Baru',
|
|
'category_ids' => [$category->id],
|
|
'variants' => [variantWithImage()],
|
|
])->assertRedirect(route('login'));
|
|
});
|
|
|
|
test('user without create permission is forbidden', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW);
|
|
|
|
$category = Category::factory()->create();
|
|
|
|
$this->actingAs($user)
|
|
->post(route('admin.master.products.store'), [
|
|
'name' => 'Produk Baru',
|
|
'category_ids' => [$category->id],
|
|
'variants' => [variantWithImage()],
|
|
])
|
|
->assertForbidden();
|
|
});
|
|
|
|
test('name is required', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW, PermissionEnum::PRODUCTS_CREATE);
|
|
|
|
$category = Category::factory()->create();
|
|
|
|
$this->actingAs($user)
|
|
->post(route('admin.master.products.store'), [
|
|
'name' => '',
|
|
'category_ids' => [$category->id],
|
|
'variants' => [variantWithImage()],
|
|
])
|
|
->assertSessionHasErrors('name');
|
|
});
|
|
|
|
test('name must not exceed 200 characters', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW, PermissionEnum::PRODUCTS_CREATE);
|
|
|
|
$category = Category::factory()->create();
|
|
|
|
$this->actingAs($user)
|
|
->post(route('admin.master.products.store'), [
|
|
'name' => str_repeat('a', 201),
|
|
'category_ids' => [$category->id],
|
|
'variants' => [variantWithImage()],
|
|
])
|
|
->assertSessionHasErrors('name');
|
|
});
|
|
|
|
test('category_ids is required', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW, PermissionEnum::PRODUCTS_CREATE);
|
|
|
|
$this->actingAs($user)
|
|
->post(route('admin.master.products.store'), [
|
|
'name' => 'Produk Baru',
|
|
'category_ids' => [],
|
|
'variants' => [variantWithImage()],
|
|
])
|
|
->assertSessionHasErrors('category_ids');
|
|
});
|
|
|
|
test('category must exist', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW, PermissionEnum::PRODUCTS_CREATE);
|
|
|
|
$this->actingAs($user)
|
|
->post(route('admin.master.products.store'), [
|
|
'name' => 'Produk Baru',
|
|
'category_ids' => [99999],
|
|
'variants' => [variantWithImage()],
|
|
])
|
|
->assertSessionHasErrors('category_ids.0');
|
|
});
|
|
|
|
test('variants is required', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW, PermissionEnum::PRODUCTS_CREATE);
|
|
|
|
$category = Category::factory()->create();
|
|
|
|
$this->actingAs($user)
|
|
->post(route('admin.master.products.store'), [
|
|
'name' => 'Produk Baru',
|
|
'category_ids' => [$category->id],
|
|
'variants' => [],
|
|
])
|
|
->assertSessionHasErrors('variants');
|
|
});
|
|
|
|
test('variant name is required', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW, PermissionEnum::PRODUCTS_CREATE);
|
|
|
|
$category = Category::factory()->create();
|
|
|
|
$this->actingAs($user)
|
|
->post(route('admin.master.products.store'), [
|
|
'name' => 'Produk Baru',
|
|
'category_ids' => [$category->id],
|
|
'variants' => [variantWithImage('', 10)],
|
|
])
|
|
->assertSessionHasErrors('variants.0.name');
|
|
});
|
|
|
|
test('variant stock is required', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW, PermissionEnum::PRODUCTS_CREATE);
|
|
|
|
$category = Category::factory()->create();
|
|
|
|
$this->actingAs($user)
|
|
->post(route('admin.master.products.store'), [
|
|
'name' => 'Produk Baru',
|
|
'category_ids' => [$category->id],
|
|
'variants' => [['name' => 'All Size', 'stock' => '', 'images' => [UploadedFile::fake()->image('test.jpg')]]],
|
|
])
|
|
->assertSessionHasErrors('variants.0.stock');
|
|
});
|
|
|
|
test('variant stock must be non-negative integer', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW, PermissionEnum::PRODUCTS_CREATE);
|
|
|
|
$category = Category::factory()->create();
|
|
|
|
$this->actingAs($user)
|
|
->post(route('admin.master.products.store'), [
|
|
'name' => 'Produk Baru',
|
|
'category_ids' => [$category->id],
|
|
'variants' => [variantWithImage('All Size', -5)],
|
|
])
|
|
->assertSessionHasErrors('variants.0.stock');
|
|
});
|
|
|
|
test('variant s3_keys is required', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW, PermissionEnum::PRODUCTS_CREATE);
|
|
|
|
$category = Category::factory()->create();
|
|
|
|
$this->actingAs($user)
|
|
->post(route('admin.master.products.store'), [
|
|
'name' => 'Produk Baru',
|
|
'category_ids' => [$category->id],
|
|
'variants' => [['name' => 'All Size', 'stock' => 10, 'retail_stock' => 0, 'prices' => defaultPrices()]],
|
|
])
|
|
->assertSessionHasErrors('variants.0.s3_keys');
|
|
});
|
|
|
|
test('approving create request activates product with variants and categories', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW, PermissionEnum::PRODUCTS_CREATE);
|
|
$verifier = createProductVerifierUser();
|
|
|
|
$cat1 = Category::factory()->create();
|
|
$cat2 = Category::factory()->create();
|
|
|
|
$this->actingAs($user)
|
|
->post(route('admin.master.products.store'), [
|
|
'name' => 'Produk Lengkap',
|
|
'description' => 'Deskripsi lengkap',
|
|
'category_ids' => [$cat1->id, $cat2->id],
|
|
'status' => 'active',
|
|
'variants' => [
|
|
variantWithImage('S', 5),
|
|
variantWithImage('M', 10),
|
|
variantWithImage('L', 15),
|
|
],
|
|
]);
|
|
|
|
$product = Product::where('name', 'Produk Lengkap')->first();
|
|
expect($product)->not->toBeNull();
|
|
expect($product->status)->toBe(ProductStatus::INACTIVE);
|
|
expect($product->categories)->toHaveCount(2);
|
|
expect($product->variants)->toHaveCount(3);
|
|
|
|
approveLatestOwnerVerificationRequest($verifier);
|
|
|
|
$product->refresh();
|
|
expect($product->status)->toBe(ProductStatus::ACTIVE);
|
|
});
|
|
|
|
test('approving create request auto-generates product slug', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW, PermissionEnum::PRODUCTS_CREATE);
|
|
$verifier = createProductVerifierUser();
|
|
|
|
$category = Category::factory()->create();
|
|
|
|
$this->actingAs($user)
|
|
->post(route('admin.master.products.store'), [
|
|
'name' => 'Batik Modern Elegan',
|
|
'category_ids' => [$category->id],
|
|
'status' => 'active',
|
|
'variants' => [variantWithImage()],
|
|
]);
|
|
|
|
$this->assertDatabaseHas('products', [
|
|
'name' => 'Batik Modern Elegan',
|
|
'slug' => 'batik-modern-elegan',
|
|
'status' => ProductStatus::INACTIVE->value,
|
|
]);
|
|
|
|
approveLatestOwnerVerificationRequest($verifier);
|
|
|
|
$this->assertDatabaseHas('products', [
|
|
'name' => 'Batik Modern Elegan',
|
|
'slug' => 'batik-modern-elegan',
|
|
'status' => ProductStatus::ACTIVE->value,
|
|
]);
|
|
});
|
|
|
|
test('rejecting create request deletes product', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW, PermissionEnum::PRODUCTS_CREATE);
|
|
$verifier = createProductVerifierUser();
|
|
|
|
$category = Category::factory()->create();
|
|
|
|
$this->actingAs($user)
|
|
->post(route('admin.master.products.store'), [
|
|
'name' => 'Produk Ditolak',
|
|
'category_ids' => [$category->id],
|
|
'status' => 'active',
|
|
'variants' => [variantWithImage()],
|
|
]);
|
|
|
|
$product = Product::where('name', 'Produk Ditolak')->first();
|
|
expect($product)->not->toBeNull();
|
|
|
|
$verificationRequest = OwnerVerificationRequest::query()->pending()->latest()->firstOrFail();
|
|
|
|
$this->actingAs($verifier)
|
|
->post(route('admin.manage.owner_verifications.reject_request', $verificationRequest), [
|
|
'reason' => 'Tidak sesuai standar',
|
|
])
|
|
->assertRedirect();
|
|
|
|
$this->assertSoftDeleted('products', ['id' => $product->id]);
|
|
});
|
|
});
|
|
|
|
// ─── Edit ─────────────────────────────────────────────────
|
|
|
|
describe('Product Edit', function () {
|
|
test('authenticated user with permission can view edit form', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW, PermissionEnum::PRODUCTS_UPDATE);
|
|
|
|
$product = createProductWithVariants();
|
|
|
|
$this->actingAs($user)
|
|
->get(route('admin.master.products.edit', $product))
|
|
->assertOk();
|
|
});
|
|
|
|
test('guest is redirected to login', function () {
|
|
$product = createProductWithVariants();
|
|
|
|
$this->get(route('admin.master.products.edit', $product))
|
|
->assertRedirect(route('login'));
|
|
});
|
|
|
|
test('user without update permission is forbidden', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW);
|
|
|
|
$product = createProductWithVariants();
|
|
|
|
$this->actingAs($user)
|
|
->get(route('admin.master.products.edit', $product))
|
|
->assertForbidden();
|
|
});
|
|
|
|
test('edit is blocked when product has pending request', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW, PermissionEnum::PRODUCTS_UPDATE);
|
|
|
|
$product = createProductWithVariants();
|
|
$category = $product->categories->first();
|
|
$variant = $product->variants->first();
|
|
|
|
$this->actingAs($user)
|
|
->put(route('admin.master.products.update', $product), [
|
|
'name' => 'Nama Diubah',
|
|
'category_ids' => [$category->id],
|
|
'status' => 'active',
|
|
'variants' => [
|
|
variantUpdateData($variant->id, $variant->name, $variant->stock),
|
|
],
|
|
]);
|
|
|
|
$this->actingAs($user)
|
|
->get(route('admin.master.products.edit', $product))
|
|
->assertRedirect(route('admin.master.products.index'));
|
|
});
|
|
});
|
|
|
|
// ─── Update ───────────────────────────────────────────────
|
|
|
|
describe('Product Update', function () {
|
|
test('authenticated user with permission can submit product update request', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW, PermissionEnum::PRODUCTS_UPDATE);
|
|
|
|
$product = createProductWithVariants();
|
|
$category = $product->categories->first();
|
|
$variant = $product->variants->first();
|
|
|
|
$this->actingAs($user)
|
|
->put(route('admin.master.products.update', $product), [
|
|
'name' => 'Nama Diubah',
|
|
'description' => 'Deskripsi baru',
|
|
'category_ids' => [$category->id],
|
|
'status' => 'active',
|
|
'variants' => [
|
|
variantUpdateData($variant->id, 'New Variant', 20),
|
|
],
|
|
])
|
|
->assertRedirect(route('admin.master.products.index'));
|
|
|
|
$this->assertDatabaseHas('owner_verification_requests', [
|
|
'subject_id' => $product->id,
|
|
'subject_type' => Product::class,
|
|
'action' => OwnerVerificationAction::UPDATE->value,
|
|
'status' => OwnerVerificationStatus::PENDING->value,
|
|
]);
|
|
|
|
expect($product->fresh()->name)->not->toBe('Nama Diubah');
|
|
});
|
|
|
|
test('approving update request applies product changes', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW, PermissionEnum::PRODUCTS_UPDATE);
|
|
$verifier = createProductVerifierUser();
|
|
|
|
$product = createProductWithVariants();
|
|
$category = $product->categories->first();
|
|
$variant = $product->variants->first();
|
|
|
|
$this->actingAs($user)
|
|
->put(route('admin.master.products.update', $product), [
|
|
'name' => 'Nama Diubah',
|
|
'description' => 'Deskripsi baru',
|
|
'category_ids' => [$category->id],
|
|
'status' => 'active',
|
|
'variants' => [
|
|
variantUpdateData($variant->id, 'New Variant', 20),
|
|
],
|
|
]);
|
|
|
|
approveLatestOwnerVerificationRequest($verifier);
|
|
|
|
expect($product->fresh()->name)->toBe('Nama Diubah');
|
|
expect($variant->fresh()->name)->toBe('New Variant');
|
|
});
|
|
|
|
test('guest cannot update a product', function () {
|
|
$product = createProductWithVariants();
|
|
$variant = $product->variants->first();
|
|
|
|
$this->put(route('admin.master.products.update', $product), [
|
|
'name' => 'Nama Baru',
|
|
'category_ids' => [$product->categories->first()->id],
|
|
'variants' => [variantUpdateData($variant->id, $variant->name, $variant->stock)],
|
|
])->assertRedirect(route('login'));
|
|
});
|
|
|
|
test('user without update permission is forbidden', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW);
|
|
|
|
$product = createProductWithVariants();
|
|
$variant = $product->variants->first();
|
|
|
|
$this->actingAs($user)
|
|
->put(route('admin.master.products.update', $product), [
|
|
'name' => 'Nama Baru',
|
|
'category_ids' => [$product->categories->first()->id],
|
|
'variants' => [variantUpdateData($variant->id, $variant->name, $variant->stock)],
|
|
])
|
|
->assertForbidden();
|
|
});
|
|
|
|
test('name is required on update', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW, PermissionEnum::PRODUCTS_UPDATE);
|
|
|
|
$product = createProductWithVariants();
|
|
$category = $product->categories->first();
|
|
$variant = $product->variants->first();
|
|
|
|
$this->actingAs($user)
|
|
->put(route('admin.master.products.update', $product), [
|
|
'name' => '',
|
|
'category_ids' => [$category->id],
|
|
'variants' => [
|
|
variantUpdateData($variant->id, $variant->name, $variant->stock),
|
|
],
|
|
])
|
|
->assertSessionHasErrors('name');
|
|
});
|
|
|
|
test('category_ids is required on update', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW, PermissionEnum::PRODUCTS_UPDATE);
|
|
|
|
$product = createProductWithVariants();
|
|
$variant = $product->variants->first();
|
|
|
|
$this->actingAs($user)
|
|
->put(route('admin.master.products.update', $product), [
|
|
'name' => 'Nama Produk',
|
|
'category_ids' => [],
|
|
'variants' => [
|
|
variantUpdateData($variant->id, $variant->name, $variant->stock),
|
|
],
|
|
])
|
|
->assertSessionHasErrors('category_ids');
|
|
});
|
|
|
|
test('approving update request removes unsubmitted variants', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW, PermissionEnum::PRODUCTS_UPDATE);
|
|
$verifier = createProductVerifierUser();
|
|
|
|
$product = createProductWithVariants();
|
|
$category = $product->categories->first();
|
|
$variantToKeep = $product->variants->first();
|
|
|
|
$this->actingAs($user)
|
|
->put(route('admin.master.products.update', $product), [
|
|
'name' => 'Updated Product',
|
|
'category_ids' => [$category->id],
|
|
'status' => 'active',
|
|
'variants' => [
|
|
variantUpdateData($variantToKeep->id, 'Kept Variant', 5),
|
|
],
|
|
]);
|
|
|
|
approveLatestOwnerVerificationRequest($verifier);
|
|
|
|
$product->refresh();
|
|
expect($product->variants)->toHaveCount(1);
|
|
expect($product->variants->first()->name)->toBe('Kept Variant');
|
|
});
|
|
});
|
|
|
|
// ─── Toggle Status ────────────────────────────────────────
|
|
|
|
describe('Product Toggle Status', function () {
|
|
test('authenticated user with permission can submit toggle status request', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW, PermissionEnum::PRODUCTS_TOGGLE_STATUS);
|
|
|
|
$product = createProductWithVariants();
|
|
|
|
$this->actingAs($user)
|
|
->patch(route('admin.master.products.toggle_status', $product), [
|
|
'status' => 'inactive',
|
|
])
|
|
->assertRedirect();
|
|
|
|
$this->assertDatabaseHas('owner_verification_requests', [
|
|
'subject_id' => $product->id,
|
|
'subject_type' => Product::class,
|
|
'action' => OwnerVerificationAction::TOGGLE_STATUS->value,
|
|
'status' => OwnerVerificationStatus::PENDING->value,
|
|
]);
|
|
|
|
expect($product->fresh()->status)->toBe(ProductStatus::ACTIVE);
|
|
});
|
|
|
|
test('product index exposes display is active for pending toggle status request', function () {
|
|
$user = createProductUserWithPermission(
|
|
PermissionEnum::PRODUCTS_VIEW,
|
|
PermissionEnum::PRODUCTS_TOGGLE_STATUS,
|
|
);
|
|
|
|
$product = createProductWithVariants();
|
|
$product->update(['status' => ProductStatus::ACTIVE]);
|
|
|
|
$this->actingAs($user)
|
|
->patch(route('admin.master.products.toggle_status', $product), [
|
|
'status' => 'inactive',
|
|
])
|
|
->assertRedirect();
|
|
|
|
$response = $this->actingAs($user)
|
|
->get(route('admin.master.products.index'));
|
|
|
|
$response->assertOk();
|
|
$response->assertInertia(fn ($page) => $page
|
|
->where('products.data.0.id', $product->id)
|
|
->where('products.data.0.status', 'active')
|
|
->where('products.data.0.display_status', 'inactive')
|
|
->where('products.data.0.has_pending_request', true)
|
|
->where('products.data.0.pending_request_action', OwnerVerificationAction::TOGGLE_STATUS->value)
|
|
);
|
|
});
|
|
|
|
test('approving toggle status request updates product status', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW, PermissionEnum::PRODUCTS_TOGGLE_STATUS);
|
|
$verifier = createProductVerifierUser();
|
|
|
|
$product = createProductWithVariants();
|
|
|
|
$this->actingAs($user)
|
|
->patch(route('admin.master.products.toggle_status', $product), [
|
|
'status' => 'inactive',
|
|
]);
|
|
|
|
approveLatestOwnerVerificationRequest($verifier);
|
|
|
|
expect($product->fresh()->status)->toBe(ProductStatus::INACTIVE);
|
|
});
|
|
|
|
test('guest cannot toggle product status', function () {
|
|
$product = createProductWithVariants();
|
|
|
|
$this->patch(route('admin.master.products.toggle_status', $product), [
|
|
'status' => 'inactive',
|
|
])->assertRedirect(route('login'));
|
|
});
|
|
|
|
test('user without toggle permission is forbidden', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW);
|
|
|
|
$product = createProductWithVariants();
|
|
|
|
$this->actingAs($user)
|
|
->patch(route('admin.master.products.toggle_status', $product), [
|
|
'status' => 'inactive',
|
|
])
|
|
->assertForbidden();
|
|
});
|
|
|
|
test('status field is required', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW, PermissionEnum::PRODUCTS_TOGGLE_STATUS);
|
|
|
|
$product = createProductWithVariants();
|
|
|
|
$this->actingAs($user)
|
|
->patch(route('admin.master.products.toggle_status', $product), [
|
|
'status' => null,
|
|
])
|
|
->assertSessionHasErrors('status');
|
|
});
|
|
});
|
|
|
|
// ─── Destroy ──────────────────────────────────────────────
|
|
|
|
describe('Product Destroy', function () {
|
|
test('authenticated user with permission can submit delete request', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW, PermissionEnum::PRODUCTS_DELETE);
|
|
|
|
$product = createProductWithVariants();
|
|
|
|
$this->actingAs($user)
|
|
->delete(route('admin.master.products.destroy', $product))
|
|
->assertRedirect(route('admin.master.products.index'));
|
|
|
|
$this->assertDatabaseHas('owner_verification_requests', [
|
|
'subject_id' => $product->id,
|
|
'subject_type' => Product::class,
|
|
'action' => OwnerVerificationAction::DELETE->value,
|
|
'status' => OwnerVerificationStatus::PENDING->value,
|
|
]);
|
|
|
|
$this->assertNotSoftDeleted('products', ['id' => $product->id]);
|
|
});
|
|
|
|
test('approving delete request soft deletes product and variants', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW, PermissionEnum::PRODUCTS_DELETE);
|
|
$verifier = createProductVerifierUser();
|
|
|
|
$product = createProductWithVariants();
|
|
$variantIds = $product->variants->pluck('id')->toArray();
|
|
|
|
$this->actingAs($user)
|
|
->delete(route('admin.master.products.destroy', $product));
|
|
|
|
approveLatestOwnerVerificationRequest($verifier);
|
|
|
|
$this->assertSoftDeleted('products', ['id' => $product->id]);
|
|
|
|
foreach ($variantIds as $variantId) {
|
|
$this->assertSoftDeleted('product_variants', ['id' => $variantId]);
|
|
}
|
|
});
|
|
|
|
test('approving delete request detaches categories', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW, PermissionEnum::PRODUCTS_DELETE);
|
|
$verifier = createProductVerifierUser();
|
|
|
|
$product = createProductWithVariants();
|
|
|
|
$this->actingAs($user)
|
|
->delete(route('admin.master.products.destroy', $product));
|
|
|
|
approveLatestOwnerVerificationRequest($verifier);
|
|
|
|
$this->assertDatabaseMissing('product_categories', ['product_id' => $product->id]);
|
|
});
|
|
|
|
test('guest cannot delete a product', function () {
|
|
$product = createProductWithVariants();
|
|
|
|
$this->delete(route('admin.master.products.destroy', $product))
|
|
->assertRedirect(route('login'));
|
|
|
|
$this->assertNotSoftDeleted('products', ['id' => $product->id]);
|
|
});
|
|
|
|
test('user without delete permission is forbidden', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW);
|
|
|
|
$product = createProductWithVariants();
|
|
|
|
$this->actingAs($user)
|
|
->delete(route('admin.master.products.destroy', $product))
|
|
->assertForbidden();
|
|
|
|
$this->assertNotSoftDeleted('products', ['id' => $product->id]);
|
|
});
|
|
});
|
|
|
|
// ─── Product Model ────────────────────────────────────────
|
|
|
|
describe('Product Model', function () {
|
|
test('product uses soft deletes', function () {
|
|
$product = Product::factory()->create();
|
|
|
|
$product->delete();
|
|
|
|
expect($product->trashed())->toBeTrue();
|
|
});
|
|
|
|
test('product can have categories', function () {
|
|
$product = Product::factory()->create();
|
|
$category = Category::factory()->create();
|
|
$product->categories()->attach($category->id);
|
|
|
|
expect($product->fresh()->categories)->toHaveCount(1);
|
|
});
|
|
|
|
test('product can have variants', function () {
|
|
$product = Product::factory()->create();
|
|
ProductVariant::factory()->count(3)->create(['product_id' => $product->id]);
|
|
|
|
expect($product->fresh()->variants)->toHaveCount(3);
|
|
});
|
|
|
|
test('product has status cast to enum', function () {
|
|
$product = Product::factory()->create();
|
|
|
|
expect($product->status)->toBeInstanceOf(ProductStatus::class);
|
|
expect($product->status)->toBe(ProductStatus::ACTIVE);
|
|
|
|
$product->update(['status' => ProductStatus::INACTIVE]);
|
|
|
|
expect($product->fresh()->status)->toBe(ProductStatus::INACTIVE);
|
|
});
|
|
|
|
test('product has total_stock_formatted accessor', function () {
|
|
$product = Product::factory()->create();
|
|
ProductVariant::factory()->create(['product_id' => $product->id, 'stock' => 10]);
|
|
ProductVariant::factory()->create(['product_id' => $product->id, 'stock' => 20]);
|
|
|
|
expect($product->fresh(['variants'])->total_stock_formatted)->toBe('30');
|
|
});
|
|
|
|
test('product has slug auto-generated', function () {
|
|
$product = Product::create(['name' => 'Test Product Name']);
|
|
|
|
expect($product->slug)->toBe('test-product-name');
|
|
});
|
|
});
|
|
|
|
// ─── ProductVariant Model ──────────────────────────────────
|
|
|
|
describe('ProductVariant Model', function () {
|
|
test('variant uses soft deletes', function () {
|
|
$product = Product::factory()->create();
|
|
$variant = ProductVariant::factory()->create(['product_id' => $product->id]);
|
|
|
|
$variant->delete();
|
|
|
|
expect($variant->trashed())->toBeTrue();
|
|
});
|
|
|
|
test('variant has stock cast to integer', function () {
|
|
$product = Product::factory()->create();
|
|
$variant = ProductVariant::factory()->create(['product_id' => $product->id, 'stock' => 50]);
|
|
|
|
expect($variant->stock)->toBeInt();
|
|
expect($variant->stock)->toBe(50);
|
|
});
|
|
|
|
test('variant has formatted stock accessor', function () {
|
|
$product = Product::factory()->create();
|
|
$variant = ProductVariant::factory()->create(['product_id' => $product->id, 'stock' => 1500]);
|
|
|
|
expect($variant->stock_formatted)->toBe('1.500');
|
|
});
|
|
|
|
test('variant belongs to product', function () {
|
|
$product = Product::factory()->create();
|
|
$variant = ProductVariant::factory()->create(['product_id' => $product->id]);
|
|
|
|
expect($variant->product)->not->toBeNull();
|
|
expect($variant->product->id)->toBe($product->id);
|
|
});
|
|
|
|
test('variant can have prices', function () {
|
|
$product = Product::factory()->create();
|
|
$variant = ProductVariant::factory()->create(['product_id' => $product->id]);
|
|
|
|
ProductPrice::factory()->count(3)->create(['variant_id' => $variant->id]);
|
|
|
|
expect($variant->fresh()->prices)->toHaveCount(3);
|
|
});
|
|
|
|
test('variant has minStock constant', function () {
|
|
expect(ProductVariant::minStock())->toBe(5);
|
|
});
|
|
});
|
|
|
|
// ─── ProductPrice Model ────────────────────────────────────
|
|
|
|
describe('ProductPrice Model', function () {
|
|
test('price has price cast to integer', function () {
|
|
$product = Product::factory()->create();
|
|
$variant = ProductVariant::factory()->create(['product_id' => $product->id]);
|
|
$price = ProductPrice::factory()->create(['variant_id' => $variant->id, 'price' => 150000]);
|
|
|
|
expect($price->price)->toBeInt();
|
|
expect($price->price)->toBe(150000);
|
|
});
|
|
|
|
test('price has formatted price accessor', function () {
|
|
$product = Product::factory()->create();
|
|
$variant = ProductVariant::factory()->create(['product_id' => $product->id]);
|
|
$price = ProductPrice::factory()->create(['variant_id' => $variant->id, 'price' => 1500000]);
|
|
|
|
expect($price->price_formatted)->toBe('Rp 1.500.000');
|
|
});
|
|
|
|
test('price has price_input accessor', function () {
|
|
$product = Product::factory()->create();
|
|
$variant = ProductVariant::factory()->create(['product_id' => $product->id]);
|
|
$price = ProductPrice::factory()->create(['variant_id' => $variant->id, 'price' => 200000]);
|
|
|
|
expect($price->price_input)->toBe('200000');
|
|
});
|
|
|
|
test('price belongs to variant', function () {
|
|
$product = Product::factory()->create();
|
|
$variant = ProductVariant::factory()->create(['product_id' => $product->id]);
|
|
$price = ProductPrice::factory()->create(['variant_id' => $variant->id]);
|
|
|
|
expect($price->variant)->not->toBeNull();
|
|
expect($price->variant->id)->toBe($variant->id);
|
|
});
|
|
});
|
|
|
|
// ─── Owner Direct Actions ──────────────────────────────────
|
|
|
|
describe('Owner Direct Actions', function () {
|
|
test('owner can create product directly without verification', function () {
|
|
$owner = createProductUserWithPermission(
|
|
PermissionEnum::PRODUCTS_VIEW,
|
|
PermissionEnum::PRODUCTS_CREATE,
|
|
PermissionEnum::OWNER_VERIFICATIONS_VERIFY,
|
|
);
|
|
|
|
$category = Category::factory()->create();
|
|
|
|
$this->actingAs($owner)
|
|
->post(route('admin.master.products.store'), [
|
|
'name' => 'Produk Owner',
|
|
'description' => 'Deskripsi',
|
|
'category_ids' => [$category->id],
|
|
'status' => 'active',
|
|
'variants' => [
|
|
variantWithImage('All Size', 10),
|
|
],
|
|
])
|
|
->assertRedirect(route('admin.master.products.index'));
|
|
|
|
$product = Product::where('name', 'Produk Owner')->first();
|
|
expect($product)->not->toBeNull();
|
|
expect($product->status)->toBe(ProductStatus::ACTIVE);
|
|
|
|
$this->assertDatabaseMissing('owner_verification_requests', [
|
|
'subject_id' => $product->id,
|
|
'subject_type' => Product::class,
|
|
]);
|
|
});
|
|
|
|
test('owner can update product directly without verification', function () {
|
|
$owner = createProductUserWithPermission(
|
|
PermissionEnum::PRODUCTS_VIEW,
|
|
PermissionEnum::PRODUCTS_UPDATE,
|
|
PermissionEnum::OWNER_VERIFICATIONS_VERIFY,
|
|
);
|
|
|
|
$product = createProductWithVariants();
|
|
$category = $product->categories->first();
|
|
$variant = $product->variants->first();
|
|
|
|
$this->actingAs($owner)
|
|
->put(route('admin.master.products.update', $product), [
|
|
'name' => 'Produk Updated',
|
|
'description' => 'Deskripsi baru',
|
|
'category_ids' => [$category->id],
|
|
'status' => 'active',
|
|
'variants' => [
|
|
variantUpdateData($variant->id, 'Updated Variant', 25),
|
|
],
|
|
])
|
|
->assertRedirect(route('admin.master.products.index'));
|
|
|
|
expect($product->fresh()->name)->toBe('Produk Updated');
|
|
expect($variant->fresh()->name)->toBe('Updated Variant');
|
|
});
|
|
|
|
test('owner can delete product directly without verification', function () {
|
|
$owner = createProductUserWithPermission(
|
|
PermissionEnum::PRODUCTS_VIEW,
|
|
PermissionEnum::PRODUCTS_DELETE,
|
|
PermissionEnum::OWNER_VERIFICATIONS_VERIFY,
|
|
);
|
|
|
|
$product = createProductWithVariants();
|
|
|
|
$this->actingAs($owner)
|
|
->delete(route('admin.master.products.destroy', $product))
|
|
->assertRedirect(route('admin.master.products.index'));
|
|
|
|
$this->assertSoftDeleted('products', ['id' => $product->id]);
|
|
});
|
|
|
|
test('owner can toggle product status directly without verification', function () {
|
|
$owner = createProductUserWithPermission(
|
|
PermissionEnum::PRODUCTS_VIEW,
|
|
PermissionEnum::PRODUCTS_TOGGLE_STATUS,
|
|
PermissionEnum::OWNER_VERIFICATIONS_VERIFY,
|
|
);
|
|
|
|
$product = createProductWithVariants();
|
|
|
|
$this->actingAs($owner)
|
|
->patch(route('admin.master.products.toggle_status', $product), [
|
|
'status' => 'inactive',
|
|
]);
|
|
|
|
expect($product->fresh()->status)->toBe(ProductStatus::INACTIVE);
|
|
});
|
|
});
|
|
|
|
// ─── Reject Update Request ─────────────────────────────────
|
|
|
|
describe('Reject Update Request', function () {
|
|
test('rejecting update request rolls back to old values', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW, PermissionEnum::PRODUCTS_UPDATE);
|
|
$verifier = createProductVerifierUser();
|
|
|
|
$product = createProductWithVariants();
|
|
$category = $product->categories->first();
|
|
$variant = $product->variants->first();
|
|
$originalName = $product->name;
|
|
$originalVariantName = $variant->name;
|
|
|
|
$this->actingAs($user)
|
|
->put(route('admin.master.products.update', $product), [
|
|
'name' => 'Nama Diubah',
|
|
'description' => 'Deskripsi baru',
|
|
'category_ids' => [$category->id],
|
|
'variants' => [
|
|
variantUpdateData($variant->id, 'New Variant', 20),
|
|
],
|
|
]);
|
|
|
|
$verificationRequest = OwnerVerificationRequest::query()->pending()->latest()->firstOrFail();
|
|
|
|
$this->actingAs($verifier)
|
|
->post(route('admin.manage.owner_verifications.reject_request', $verificationRequest), [
|
|
'reason' => 'Tidak sesuai standar',
|
|
])
|
|
->assertRedirect();
|
|
|
|
expect($product->fresh()->name)->toBe($originalName);
|
|
expect($variant->fresh()->name)->toBe($originalVariantName);
|
|
});
|
|
});
|
|
|
|
// ─── Show JSON ────────────────────────────────────────────
|
|
|
|
describe('Product Show JSON', function () {
|
|
test('authenticated user with permission can get product details in JSON', function () {
|
|
$user = createProductUserWithPermission(PermissionEnum::PRODUCTS_VIEW);
|
|
|
|
$product = createProductWithVariants();
|
|
|
|
$response = $this->actingAs($user)
|
|
->get(route('admin.master.products.show', $product))
|
|
->assertOk();
|
|
|
|
$response->assertJsonStructure([
|
|
'id',
|
|
'name',
|
|
'description',
|
|
'categories' => [
|
|
'*' => [
|
|
'id',
|
|
'name',
|
|
],
|
|
],
|
|
'variants' => [
|
|
'*' => [
|
|
'id',
|
|
'product_id',
|
|
'name',
|
|
'stock',
|
|
'reject_stock',
|
|
'retail_stock',
|
|
'prices' => [
|
|
'*' => [
|
|
'id',
|
|
'variant_id',
|
|
'type',
|
|
'price',
|
|
],
|
|
],
|
|
'images',
|
|
],
|
|
],
|
|
]);
|
|
|
|
$data = $response->json();
|
|
expect($data['id'])->toBe($product->id);
|
|
expect($data['variants'])->toHaveCount(2);
|
|
});
|
|
|
|
test('guest cannot get product details in JSON', function () {
|
|
$product = createProductWithVariants();
|
|
|
|
$this->get(route('admin.master.products.show', $product))
|
|
->assertRedirect(route('login'));
|
|
});
|
|
|
|
test('user without view permission cannot get product details in JSON', function () {
|
|
$user = User::factory()->create();
|
|
|
|
$product = createProductWithVariants();
|
|
|
|
$this->actingAs($user)
|
|
->get(route('admin.master.products.show', $product))
|
|
->assertForbidden();
|
|
});
|
|
});
|