tbianchini/shopit-back
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add tests for ticket validity and event date formatting

Browse Source 
- Create TicketValiditySchemaTest to verify database schema for ticket validity.
- Update CatalogModelsTest to include tests for event date attributes and selection options.
- Introduce EventDateTextFormatterTest for formatting event dates in Spanish.
- Refactor EventModelsTest to include validity time relationships.
- Add SaleDetailResourceTest to ensure correct serialization of purchase items.
- Enhance TicketTest with validity time checks and status management.
- Implement ValidityTimeResourceTest to validate resource output for different validity types.
- Add ValidityTimeTest to verify casting and validity checks for validity time types.
This commit is contained in:
ncoronel
2026-08-11 12:41:35 -03:00
parent b294e5c46e
commit 02cf3f3773
166 changed files with 10203 additions and 1849 deletions
Download Patch File Download Diff File Expand all files Collapse all files

266
tests/Feature/FiestaFutbolInfantil/AccommodationControllerTest.php Normal file
View File

@@ -0,0 +1,266 @@
<?php
namespace Tests\Feature\FiestaFutbolInfantil;
use App\Domains\Attachable\Enums\AttachmentType;
use App\Domains\Attachable\Models\Attachment;
use App\Domains\Auth\Models\User;
use App\Domains\Authorization\Enums\RoleCode;
use App\Domains\Catalog\Models\Attribute;
use App\Domains\Catalog\Models\CatalogItem;
use App\Domains\Menu\Models\Menu;
use App\Domains\Shared\Enums\FieldType;
use App\Domains\Tenant\Models\Tenant;
use App\Domains\Tenant\Models\WebsiteType;
use Database\Seeders\AuthorizationSeeder;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Laravel\Sanctum\Sanctum;
use Tests\TestCase;
class AccommodationControllerTest extends TestCase
{
use RefreshDatabase;
protected function setUp(): void
{
parent::setUp();
$this->seed(AuthorizationSeeder::class);
WebsiteType::query()->create([
'codigo' => 'onticket',
'nombre' => 'OnTicket',
]);
}
public function test_authentication_is_required(): void
{
$this->postJson('/api/v1/adminapp/tenant/accommodations', ['variants' => []])
->assertUnauthorized();
}
public function test_it_creates_accommodation_variants_and_adds_type_options(): void
{
[$tenant, $attribute] = $this->configuredTenant();
Sanctum::actingAs($this->createAdminAppUser($tenant));
$this->postJson('/api/v1/adminapp/tenant/accommodations', [
'variants' => [
$this->variantPayload('Casa Rodante Familiar', 'Parcela grande', 25, 45000),
$this->variantPayload('Carpa', null, 100, 35000),
],
])
->assertOk()
->assertJsonPath('data.name', 'Alojamiento')
->assertJsonCount(2, 'data.variants')
->assertJsonPath('data.variants.0.title', 'Casa Rodante Familiar')
->assertJsonPath('data.variants.0.value', 'casa_rodante_familiar')
->assertJsonPath('data.variants.0.description', 'Parcela grande')
->assertJsonPath('data.variants.0.stock', 25)
->assertJsonPath('data.variants.0.price', '45000.00');
$this->getJson('/api/v1/adminapp/tenant/accommodations')
->assertOk()
->assertJsonPath('data.name', 'Alojamiento')
->assertJsonCount(2, 'data.variants')
->assertJsonPath('data.variants.0.title', 'Casa Rodante Familiar')
->assertJsonPath('data.variants.1.title', 'Carpa');
$this->assertDatabaseHas('attribute_options', [
'attribute_id' => $attribute->id,
'value' => 'casa_rodante_familiar',
'label' => 'Casa Rodante Familiar',
]);
$this->assertDatabaseHas('attribute_options', [
'attribute_id' => $attribute->id,
'value' => 'carpa',
'label' => 'Carpa',
]);
$this->assertDatabaseCount('catalog_items', 1);
$this->assertTrue(CatalogItem::query()->sole()->has_tickets);
$this->assertDatabaseCount('variantes', 2);
$this->assertDatabaseCount('inventories', 2);
$this->assertDatabaseCount('variant_values', 2);
}
public function test_it_updates_variants_with_an_id_and_creates_variants_without_one(): void
{
[$tenant, $attribute] = $this->configuredTenant();
Sanctum::actingAs($this->createAdminAppUser($tenant));
$created = $this->postJson('/api/v1/adminapp/tenant/accommodations', [
'variants' => [
$this->variantPayload('Casa Rodante', 'Descripción inicial', 20, 40000),
],
])->assertOk();
$variantId = $created->json('data.variants.0.id');
$updated = $this->variantPayload('Casa Rodante Premium', 'Con electricidad', 15, 50000);
$updated['id'] = $variantId;
$this->postJson('/api/v1/adminapp/tenant/accommodations', [
'variants' => [
$updated,
$this->variantPayload('Motor Home', null, 10, 60000),
],
])
->assertOk()
->assertJsonCount(2, 'data.variants')
->assertJsonPath('data.variants.0.id', $variantId)
->assertJsonPath('data.variants.0.title', 'Casa Rodante Premium')
->assertJsonPath('data.variants.0.value', 'casa_rodante_premium')
->assertJsonPath('data.variants.0.stock', 15)
->assertJsonPath('data.variants.1.value', 'motor_home');
$this->assertDatabaseMissing('attribute_options', [
'attribute_id' => $attribute->id,
'value' => 'casa_rodante',
]);
$this->assertDatabaseHas('attribute_options', [
'attribute_id' => $attribute->id,
'value' => 'casa_rodante_premium',
'label' => 'Casa Rodante Premium',
]);
$this->assertDatabaseHas('variant_values', [
'variant_id' => $variantId,
'value' => 'casa_rodante_premium',
]);
$this->assertDatabaseCount('variantes', 2);
}
public function test_it_deletes_an_accommodation_and_its_empty_product(): void
{
[$tenant] = $this->configuredTenant();
Sanctum::actingAs($this->createAdminAppUser($tenant));
$accommodationId = $this->postJson('/api/v1/adminapp/tenant/accommodations', [
'variants' => [
$this->variantPayload('Carpa', null, 100, 35000),
],
])->assertOk()->json('data.variants.0.id');
$this->deleteJson("/api/v1/adminapp/tenant/accommodations/{$accommodationId}")
->assertNoContent();
$this->assertDatabaseCount('catalog_items', 0);
$this->assertDatabaseCount('variantes', 0);
$this->assertDatabaseCount('inventories', 0);
}
public function test_it_rejects_duplicate_normalized_titles(): void
{
[$tenant] = $this->configuredTenant();
Sanctum::actingAs($this->createAdminAppUser($tenant));
$this->postJson('/api/v1/adminapp/tenant/accommodations', [
'variants' => [
$this->variantPayload('Casa Rodante', null, 10, 40000),
$this->variantPayload(' CASA RODANTE ', null, 10, 40000),
],
])
->assertUnprocessable()
->assertJsonValidationErrors('variants.1.title');
$this->assertDatabaseCount('catalog_items', 0);
$this->assertDatabaseCount('attribute_options', 0);
}
public function test_the_tenant_must_have_the_accommodations_menu(): void
{
[$tenant] = $this->configuredTenant(withMenu: false);
Sanctum::actingAs($this->createAdminAppUser($tenant));
$this->postJson('/api/v1/adminapp/tenant/accommodations', [
'variants' => [
$this->variantPayload('Carpa', null, 10, 35000),
],
])->assertNotFound();
$this->assertDatabaseCount('catalog_items', 0);
}
public function test_a_different_tenant_can_use_the_endpoint_when_it_has_the_menu(): void
{
[$tenant] = $this->configuredTenant('another_tenant');
Sanctum::actingAs($this->createAdminAppUser($tenant));
$this->postJson('/api/v1/adminapp/tenant/accommodations', [
'variants' => [
$this->variantPayload('Dormitorio Compartido', null, 30, 25000),
],
])
->assertOk()
->assertJsonPath('data.variants.0.value', 'dormitorio_compartido');
}
/** @return array{Tenant, Attribute} */
private function configuredTenant(
string $tenantCode = 'fiesta_futbol_infantil',
bool $withMenu = true,
): array {
$headerLogo = Attachment::query()->create([
'path' => 'test/header.png',
'filename' => 'header.png',
'type' => AttachmentType::Image,
'mime_type' => 'image/png',
]);
$footerLogo = Attachment::query()->create([
'path' => 'test/footer.png',
'filename' => 'footer.png',
'type' => AttachmentType::Image,
'mime_type' => 'image/png',
]);
$tenant = Tenant::query()->create([
'codigo' => $tenantCode,
'nombre' => 'Fiesta Fútbol Infantil',
'dominio' => 'fiesta.test',
'primary_color' => '#112233',
'secondary_color' => '#445566',
'danger_color' => '#cc0000',
'header_bg_color' => '#ffffff',
'footer_bg_color' => '#111111',
'header_logo_id' => $headerLogo->id,
'footer_logo_id' => $footerLogo->id,
'website_type_code' => 'onticket',
]);
$attribute = Attribute::query()->create([
'tenant_codigo' => $tenant->codigo,
'codigo' => 'tipo_alojamiento',
'nombre' => 'TipoAlojamiento',
'type' => FieldType::Select,
'is_required' => true,
]);
if ($withMenu) {
$menu = Menu::query()->firstOrCreate(
['code' => 'adminapp.fiesta-futbol-infantil.alojamientos'],
['label' => 'Alojamientos', 'route' => '/admin/alojamientos'],
);
$tenant->menues()->syncWithoutDetaching([$menu->code]);
}
return [$tenant, $attribute];
}
/** @return array<string, mixed> */
private function variantPayload(
string $title,
?string $description,
int $stock,
float $price,
): array {
return [
'title' => $title,
'description' => $description,
'stock' => $stock,
'price' => $price,
];
}
private function createAdminAppUser(Tenant $tenant): User
{
return User::factory()->create([
'rol_codigo' => RoleCode::AdminApp->value,
'tenant_codigo' => $tenant->codigo,
]);
}
}

329
tests/Feature/FiestaFutbolInfantil/EntryControllerTest.php Normal file
View File

@@ -0,0 +1,329 @@
<?php
namespace Tests\Feature\FiestaFutbolInfantil;
use App\Domains\Auth\Models\User;
use App\Domains\Authorization\Enums\RoleCode;
use App\Domains\Catalog\Models\Attribute;
use App\Domains\Catalog\Models\CatalogItem;
use App\Domains\Catalog\Models\Category;
use App\Domains\Menu\Models\Menu;
use App\Domains\Shared\Enums\FieldType;
use App\Domains\Tenant\Models\Tenant;
use App\Domains\Tenant\Models\WebsiteType;
use Database\Seeders\AuthorizationSeeder;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Laravel\Sanctum\Sanctum;
use Tests\TestCase;
class EntryControllerTest extends TestCase
{
use RefreshDatabase;
protected function setUp(): void
{
parent::setUp();
$this->seed(AuthorizationSeeder::class);
WebsiteType::query()->create([
'codigo' => 'onticket',
'nombre' => 'OnTicket',
]);
}
public function test_authentication_is_required(): void
{
$this->postJson('/api/v1/adminapp/tenant/entries', ['entries' => []])
->assertUnauthorized();
}
public function test_it_creates_multiple_entries_with_dates_and_tracked_inventory(): void
{
$tenant = $this->createFiestaTenant();
$this->createEventDateAttribute($tenant);
$firstDate = $tenant->eventDates()->create([
'date' => '2026-10-09',
'time_start' => '00:00',
'time_end' => '23:59',
]);
$secondDate = $tenant->eventDates()->create([
'date' => '2026-10-10',
'time_start' => '00:00',
'time_end' => '23:59',
]);
Sanctum::actingAs($this->createAdminAppUser($tenant));
$this->postJson('/api/v1/adminapp/tenant/entries', [
'entries' => [
[
'title' => 'Abono',
'description' => 'Acceso para ambas jornadas',
'event_date_ids' => [$firstDate->id, $secondDate->id],
'stock' => 1000,
'price' => 10000,
],
[
'title' => 'Entrada diaria',
'description' => null,
'event_date_ids' => [$firstDate->id],
'stock' => 250,
'price' => 5000.50,
],
],
])
->assertOk()
->assertJsonCount(2, 'data')
->assertJsonPath('data.0.title', 'Abono')
->assertJsonPath('data.0.event_date_ids', [$firstDate->id, $secondDate->id])
->assertJsonPath('data.0.stock', 1000)
->assertJsonPath('data.0.price', '10000.00')
->assertJsonPath('data.1.title', 'Entrada diaria')
->assertJsonPath('data.1.price', '5000.50');
$this->getJson('/api/v1/adminapp/tenant/entries')
->assertOk()
->assertJsonCount(2, 'data')
->assertJsonPath('data.0.title', 'Abono')
->assertJsonPath('data.0.event_date_ids', [$firstDate->id, $secondDate->id])
->assertJsonPath('data.1.title', 'Entrada diaria');
$this->assertDatabaseCount('catalog_items', 2);
$this->assertDatabaseCount('variantes', 2);
$this->assertDatabaseCount('inventories', 2);
$this->assertDatabaseCount('variant_event_dates', 3);
$entryCategory = Category::query()
->where('tenant_code', $tenant->codigo)
->where('nombre', 'Entradas')
->sole();
CatalogItem::query()->each(function (CatalogItem $entry) use ($tenant, $entryCategory): void {
$this->assertSame($tenant->codigo, $entry->tenant_code);
$this->assertSame($entryCategory->id, $entry->category_id);
$this->assertSame('tracked', $entry->inventory_policy->value);
$this->assertTrue($entry->has_tickets);
$this->assertNull($entry->inventory_id);
});
}
public function test_it_updates_entries_with_an_id_and_creates_entries_without_one(): void
{
$tenant = $this->createFiestaTenant();
$this->createEventDateAttribute($tenant);
$firstDate = $tenant->eventDates()->create([
'date' => '2026-10-09',
'time_start' => '00:00',
'time_end' => '23:59',
]);
$secondDate = $tenant->eventDates()->create([
'date' => '2026-10-10',
'time_start' => '00:00',
'time_end' => '23:59',
]);
Sanctum::actingAs($this->createAdminAppUser($tenant));
$createdId = $this->postJson('/api/v1/adminapp/tenant/entries', [
'entries' => [[
'title' => 'Abono original',
'description' => null,
'event_date_ids' => [$firstDate->id],
'stock' => 10,
'price' => 100,
]],
])->assertOk()->json('data.0.id');
$this->postJson('/api/v1/adminapp/tenant/entries', [
'entries' => [
[
'id' => $createdId,
'title' => 'Abono actualizado',
'description' => 'Ahora incluye ambas fechas',
'event_date_ids' => [$firstDate->id, $secondDate->id],
'stock' => 20,
'price' => 250,
],
[
'title' => 'Entrada nueva',
'description' => null,
'event_date_ids' => [$secondDate->id],
'stock' => 30,
'price' => 300,
],
],
])
->assertOk()
->assertJsonCount(2, 'data')
->assertJsonPath('data.0.id', $createdId)
->assertJsonPath('data.0.title', 'Abono actualizado')
->assertJsonPath('data.0.event_date_ids', [$firstDate->id, $secondDate->id])
->assertJsonPath('data.0.stock', 20)
->assertJsonPath('data.1.title', 'Entrada nueva');
$this->assertDatabaseCount('catalog_items', 2);
$this->assertDatabaseHas('catalog_items', [
'id' => $createdId,
'nombre' => 'Abono actualizado',
'precio' => 250,
]);
}
public function test_it_deletes_an_entry_and_its_inventory(): void
{
$tenant = $this->createFiestaTenant();
$this->createEventDateAttribute($tenant);
$eventDate = $tenant->eventDates()->create([
'date' => '2026-10-09',
'time_start' => '00:00',
'time_end' => '23:59',
]);
Sanctum::actingAs($this->createAdminAppUser($tenant));
$entryId = $this->postJson('/api/v1/adminapp/tenant/entries', [
'entries' => [[
'title' => 'Entrada diaria',
'description' => null,
'event_date_ids' => [$eventDate->id],
'stock' => 100,
'price' => 5000,
]],
])->assertOk()->json('data.0.id');
$this->deleteJson("/api/v1/adminapp/tenant/entries/{$entryId}")
->assertNoContent();
$this->assertDatabaseCount('catalog_items', 0);
$this->assertDatabaseCount('variantes', 0);
$this->assertDatabaseCount('inventories', 0);
}
public function test_dates_must_belong_to_the_authenticated_tenant(): void
{
$tenant = $this->createFiestaTenant();
$otherTenant = $this->createTenant('other');
$this->createEventDateAttribute($tenant);
$foreignDate = $otherTenant->eventDates()->create([
'date' => '2026-10-09',
'time_start' => '00:00',
'time_end' => '23:59',
]);
Sanctum::actingAs($this->createAdminAppUser($tenant));
$this->postJson('/api/v1/adminapp/tenant/entries', [
'entries' => [[
'title' => 'Entrada inválida',
'description' => null,
'event_date_ids' => [$foreignDate->id],
'stock' => 10,
'price' => 100,
]],
])
->assertUnprocessable()
->assertJsonValidationErrors(['entries.0.event_date_ids.0']);
$this->assertDatabaseCount('catalog_items', 0);
}
public function test_entries_are_identified_by_the_entries_category(): void
{
$tenant = $this->createFiestaTenant();
$this->createEventDateAttribute($tenant);
$eventDate = $tenant->eventDates()->create([
'date' => '2026-10-09',
'time_start' => '00:00',
'time_end' => '23:59',
]);
$merchandisingCategory = Category::query()->create([
'tenant_code' => $tenant->codigo,
'nombre' => 'Merchandising',
]);
$merchandise = CatalogItem::query()->create([
'tenant_code' => $tenant->codigo,
'category_id' => $merchandisingCategory->id,
'slug' => 'camiseta',
'nombre' => 'Camiseta',
'precio' => 100,
]);
Sanctum::actingAs($this->createAdminAppUser($tenant));
$this->getJson('/api/v1/adminapp/tenant/entries')
->assertOk()
->assertJsonCount(0, 'data');
$this->postJson('/api/v1/adminapp/tenant/entries', [
'entries' => [[
'id' => $merchandise->id,
'title' => 'Entrada inválida',
'description' => null,
'event_date_ids' => [$eventDate->id],
'stock' => 10,
'price' => 100,
]],
])
->assertUnprocessable()
->assertJsonValidationErrors(['entries.0.id']);
}
public function test_the_endpoint_is_only_available_for_fiesta_futbol_infantil(): void
{
$tenant = $this->createTenant('other');
$this->createEventDateAttribute($tenant);
$eventDate = $tenant->eventDates()->create([
'date' => '2026-10-09',
'time_start' => '00:00',
'time_end' => '23:59',
]);
Sanctum::actingAs($this->createAdminAppUser($tenant));
$this->postJson('/api/v1/adminapp/tenant/entries', [
'entries' => [[
'title' => 'Entrada',
'description' => null,
'event_date_ids' => [$eventDate->id],
'stock' => 10,
'price' => 100,
]],
])->assertNotFound();
}
private function createFiestaTenant(): Tenant
{
$tenant = $this->createTenant('fiesta_futbol_infantil');
$menu = Menu::query()->create([
'code' => 'adminapp.fiesta-futbol-infantil.entradas',
'label' => 'Entradas',
'route' => '/admin/entradas',
]);
$tenant->menues()->attach($menu->code);
return $tenant;
}
private function createTenant(string $code): Tenant
{
return Tenant::query()->create([
'codigo' => $code,
'nombre' => ucfirst($code),
'dominio' => "{$code}.test",
'website_type_code' => 'onticket',
]);
}
private function createEventDateAttribute(Tenant $tenant): void
{
Attribute::query()->create([
'tenant_codigo' => $tenant->codigo,
'codigo' => 'event_date',
'nombre' => 'Fecha',
'type' => FieldType::EventDate,
'is_required' => true,
]);
}
private function createAdminAppUser(Tenant $tenant): User
{
return User::factory()->create([
'rol_codigo' => RoleCode::AdminApp->value,
'tenant_codigo' => $tenant->codigo,
]);
}
}

279
tests/Feature/FiestaFutbolInfantil/FoodControllerTest.php Normal file
View File

@@ -0,0 +1,279 @@
<?php
namespace Tests\Feature\FiestaFutbolInfantil;
use App\Domains\Auth\Models\User;
use App\Domains\Authorization\Enums\RoleCode;
use App\Domains\Catalog\Models\Attribute;
use App\Domains\Catalog\Models\CatalogItem;
use App\Domains\Catalog\Models\Category;
use App\Domains\Menu\Models\Menu;
use App\Domains\Shared\Enums\FieldType;
use App\Domains\Tenant\Models\Tenant;
use App\Domains\Tenant\Models\WebsiteType;
use Database\Seeders\AuthorizationSeeder;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Laravel\Sanctum\Sanctum;
use Tests\TestCase;
class FoodControllerTest extends TestCase
{
use RefreshDatabase;
protected function setUp(): void
{
parent::setUp();
$this->seed(AuthorizationSeeder::class);
WebsiteType::query()->create([
'codigo' => 'onticket',
'nombre' => 'OnTicket',
]);
}
public function test_authentication_is_required(): void
{
$this->postJson('/api/v1/adminapp/tenant/foods', ['variants' => []])
->assertUnauthorized();
}
public function test_it_creates_one_food_item_with_multiple_variants(): void
{
[$tenant, $firstDate, $secondDate] = $this->configuredTenant();
Sanctum::actingAs($this->createAdminAppUser($tenant));
$this->postJson('/api/v1/adminapp/tenant/foods', [
'variants' => [
$this->variantPayload($firstDate->id, 'Almuerzo', 'Comedor', 1700, 10000),
$this->variantPayload($secondDate->id, 'Cena', 'Vianda', 900, 8000),
],
])
->assertOk()
->assertJsonPath('data.name', 'Comida')
->assertJsonCount(2, 'data.variants')
->assertJsonPath('data.variants.0.schedule', 'Almuerzo')
->assertJsonPath('data.variants.0.service', 'Comedor')
->assertJsonPath('data.variants.0.stock', 1700)
->assertJsonPath('data.variants.0.price', '10000.00')
->assertJsonPath('data.variants.1.price', '8000.00');
$this->getJson('/api/v1/adminapp/tenant/foods')
->assertOk()
->assertJsonPath('data.name', 'Comida')
->assertJsonCount(2, 'data.variants')
->assertJsonPath('data.variants.0.schedule', 'Almuerzo')
->assertJsonPath('data.variants.1.service', 'Vianda');
$this->assertDatabaseCount('catalog_items', 1);
$this->assertDatabaseCount('variantes', 2);
$this->assertDatabaseCount('inventories', 2);
$this->assertDatabaseCount('variant_event_dates', 2);
$this->assertDatabaseCount('variant_values', 4);
$food = CatalogItem::query()->where('slug', 'comida')->sole();
$this->assertDatabaseHas('item_attributes', [
'catalog_item_id' => $food->id,
'attribute_id' => Attribute::query()->where('codigo', 'event_date')->sole()->id,
'sort_order' => 1,
]);
$this->assertDatabaseHas('item_attributes', [
'catalog_item_id' => $food->id,
'attribute_id' => Attribute::query()->where('codigo', 'horario')->sole()->id,
'sort_order' => 2,
]);
$this->assertDatabaseHas('item_attributes', [
'catalog_item_id' => $food->id,
'attribute_id' => Attribute::query()->where('codigo', 'servicio')->sole()->id,
'sort_order' => 3,
]);
$this->assertDatabaseHas('catalog_items', [
'tenant_code' => $tenant->codigo,
'slug' => 'comida',
'nombre' => 'Comida',
'has_tickets' => true,
'category_id' => Category::query()
->where('tenant_code', $tenant->codigo)
->where('nombre', 'Comidas')
->sole()
->id,
'precio' => 8000,
]);
}
public function test_it_updates_variants_with_an_id_and_creates_variants_without_one(): void
{
[$tenant, $firstDate, $secondDate] = $this->configuredTenant();
Sanctum::actingAs($this->createAdminAppUser($tenant));
$created = $this->postJson('/api/v1/adminapp/tenant/foods', [
'variants' => [
$this->variantPayload($firstDate->id, 'Almuerzo', 'Comedor', 100, 10000),
],
])->assertOk();
$variantId = $created->json('data.variants.0.id');
$updated = $this->variantPayload($secondDate->id, 'Cena', 'Vianda', 80, 8500);
$updated['id'] = $variantId;
$updated['description'] = 'Cena para llevar';
$this->postJson('/api/v1/adminapp/tenant/foods', [
'variants' => [
$updated,
$this->variantPayload($firstDate->id, 'Almuerzo', 'Vianda', 50, 9000),
],
])
->assertOk()
->assertJsonCount(2, 'data.variants')
->assertJsonPath('data.variants.0.id', $variantId)
->assertJsonPath('data.variants.0.event_date_id', $secondDate->id)
->assertJsonPath('data.variants.0.schedule', 'Cena')
->assertJsonPath('data.variants.0.service', 'Vianda')
->assertJsonPath('data.variants.0.description', 'Cena para llevar')
->assertJsonPath('data.variants.0.stock', 80)
->assertJsonPath('data.variants.0.price', '8500.00');
$this->assertDatabaseCount('catalog_items', 1);
$this->assertDatabaseCount('variantes', 2);
$this->assertDatabaseHas('variantes', [
'id' => $variantId,
'event_date_id' => $secondDate->id,
'descripcion' => 'Cena para llevar',
'precio' => 8500,
]);
}
public function test_it_deletes_food_records_and_removes_the_empty_product(): void
{
[$tenant, $firstDate, $secondDate] = $this->configuredTenant();
Sanctum::actingAs($this->createAdminAppUser($tenant));
$created = $this->postJson('/api/v1/adminapp/tenant/foods', [
'variants' => [
$this->variantPayload($firstDate->id, 'Almuerzo', 'Comedor', 100, 10000),
$this->variantPayload($secondDate->id, 'Cena', 'Vianda', 50, 8000),
],
])->assertOk();
$firstId = $created->json('data.variants.0.id');
$secondId = $created->json('data.variants.1.id');
$this->deleteJson("/api/v1/adminapp/tenant/foods/{$secondId}")
->assertNoContent();
$this->assertDatabaseHas('catalog_items', [
'tenant_code' => $tenant->codigo,
'slug' => 'comida',
'precio' => 10000,
]);
$this->assertDatabaseCount('variantes', 1);
$this->assertDatabaseCount('inventories', 1);
$this->deleteJson("/api/v1/adminapp/tenant/foods/{$firstId}")
->assertNoContent();
$this->assertDatabaseCount('catalog_items', 0);
$this->assertDatabaseCount('variantes', 0);
$this->assertDatabaseCount('inventories', 0);
}
public function test_it_rejects_duplicate_combinations(): void
{
[$tenant, $firstDate] = $this->configuredTenant();
Sanctum::actingAs($this->createAdminAppUser($tenant));
$this->postJson('/api/v1/adminapp/tenant/foods', [
'variants' => [
$this->variantPayload($firstDate->id, 'Almuerzo', 'Comedor', 100, 10000),
$this->variantPayload($firstDate->id, ' almuerzo ', ' comedor ', 100, 10000),
],
])
->assertUnprocessable()
->assertJsonValidationErrors(['variants.1']);
$this->assertDatabaseCount('catalog_items', 0);
}
/** @return array{Tenant, mixed, mixed} */
private function configuredTenant(): array
{
$tenant = Tenant::query()->create([
'codigo' => 'fiesta_futbol_infantil',
'nombre' => 'Fiesta Fútbol Infantil',
'dominio' => 'fiesta.test',
'website_type_code' => 'onticket',
]);
$eventDateAttribute = Attribute::query()->create([
'tenant_codigo' => $tenant->codigo,
'codigo' => 'event_date',
'nombre' => 'Fecha',
'type' => FieldType::EventDate,
'is_required' => true,
]);
$scheduleAttribute = Attribute::query()->create([
'tenant_codigo' => $tenant->codigo,
'codigo' => 'horario',
'nombre' => 'Horario',
'type' => FieldType::Select,
'is_required' => true,
]);
$scheduleAttribute->options()->createMany([
['value' => 'Almuerzo', 'label' => 'Almuerzo', 'sort_order' => 1],
['value' => 'Cena', 'label' => 'Cena', 'sort_order' => 2],
]);
$serviceAttribute = Attribute::query()->create([
'tenant_codigo' => $tenant->codigo,
'codigo' => 'servicio',
'nombre' => 'Servicio',
'type' => FieldType::Select,
'is_required' => true,
]);
$serviceAttribute->options()->createMany([
['value' => 'Comedor', 'label' => 'Comedor', 'sort_order' => 1],
['value' => 'Vianda', 'label' => 'Vianda', 'sort_order' => 2],
]);
$firstDate = $tenant->eventDates()->create([
'date' => '2026-10-09',
'time_start' => '00:00',
'time_end' => '23:59',
]);
$secondDate = $tenant->eventDates()->create([
'date' => '2026-10-10',
'time_start' => '00:00',
'time_end' => '23:59',
]);
$menu = Menu::query()->create([
'code' => 'adminapp.fiesta-futbol-infantil.comida',
'label' => 'Comida',
'route' => '/admin/comidas',
]);
$tenant->menues()->attach($menu->code);
$this->assertNotNull($eventDateAttribute);
return [$tenant, $firstDate, $secondDate];
}
/** @return array<string, mixed> */
private function variantPayload(
int $eventDateId,
string $schedule,
string $service,
int $stock,
float $price,
): array {
return [
'event_date_id' => $eventDateId,
'schedule' => $schedule,
'service' => $service,
'description' => null,
'stock' => $stock,
'price' => $price,
];
}
private function createAdminAppUser(Tenant $tenant): User
{
return User::factory()->create([
'rol_codigo' => RoleCode::AdminApp->value,
'tenant_codigo' => $tenant->codigo,
]);
}
}

344
tests/Feature/FiestaFutbolInfantil/MerchandiseControllerTest.php Normal file
View File

@@ -0,0 +1,344 @@
<?php
namespace Tests\Feature\FiestaFutbolInfantil;
use App\Domains\Attachable\Enums\AttachmentType;
use App\Domains\Attachable\Models\Attachment;
use App\Domains\Auth\Models\User;
use App\Domains\Authorization\Enums\RoleCode;
use App\Domains\Catalog\Models\Attribute;
use App\Domains\Menu\Models\Menu;
use App\Domains\Shared\Enums\FieldType;
use App\Domains\Tenant\Models\Tenant;
use App\Domains\Tenant\Models\WebsiteType;
use Database\Seeders\AuthorizationSeeder;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Laravel\Sanctum\Sanctum;
use Tests\TestCase;
class MerchandiseControllerTest extends TestCase
{
use RefreshDatabase;
protected function setUp(): void
{
parent::setUp();
$this->seed(AuthorizationSeeder::class);
WebsiteType::query()->create([
'codigo' => 'onticket',
'nombre' => 'OnTicket',
]);
}
public function test_authentication_is_required(): void
{
$this->postJson('/api/v1/adminapp/tenant/merchandise', ['items' => []])
->assertUnauthorized();
}
public function test_it_creates_multiple_items_with_color_and_size_variants(): void
{
[$tenant, $colorAttribute] = $this->configuredTenant();
Sanctum::actingAs($this->createAdminAppUser($tenant));
$this->postJson('/api/v1/adminapp/tenant/merchandise', [
'items' => [
$this->itemPayload('Camiseta', 3, [
$this->variantPayload('Verde', 'S', 1700, 100000),
$this->variantPayload('Verde', 'M', 1600, 95000),
$this->variantPayload('Azul Marino', 'L', 500, 110000),
]),
$this->itemPayload('Buzo', 2, [
$this->variantPayload('Blanco', 'XL', 300, 120000),
]),
],
])
->assertOk()
->assertJsonCount(2, 'data')
->assertJsonPath('data.0.title', 'Camiseta')
->assertJsonPath('data.0.max_units_per_user', 3)
->assertJsonCount(3, 'data.0.variants')
->assertJsonPath('data.0.variants.0.color', 'Verde')
->assertJsonPath('data.0.variants.0.color_value', 'Verde')
->assertJsonPath('data.0.variants.0.size', 'S')
->assertJsonPath('data.0.variants.0.stock', 1700)
->assertJsonPath('data.0.variants.1.price', '95000.00')
->assertJsonPath('data.0.variants.2.color', 'Azul Marino')
->assertJsonPath('data.0.variants.2.color_value', 'azul_marino');
$this->getJson('/api/v1/adminapp/tenant/merchandise')
->assertOk()
->assertJsonCount(2, 'data')
->assertJsonPath('data.0.title', 'Camiseta')
->assertJsonCount(3, 'data.0.variants')
->assertJsonPath('data.1.title', 'Buzo')
->assertJsonPath('data.1.variants.0.size', 'XL');
$this->assertDatabaseCount('catalog_items', 2);
$this->assertDatabaseCount('variantes', 4);
$this->assertDatabaseCount('inventories', 4);
$this->assertDatabaseCount('item_attributes', 4);
$this->assertDatabaseCount('variant_values', 8);
$this->assertDatabaseHas('attribute_options', [
'attribute_id' => $colorAttribute->id,
'value' => 'azul_marino',
'label' => 'Azul Marino',
]);
$this->assertDatabaseHas('catalog_items', [
'nombre' => 'Camiseta',
'precio' => 95000,
'max_units_per_user' => 3,
'inventory_policy' => 'tracked',
'has_tickets' => true,
]);
}
public function test_it_updates_items_and_variants_with_ids_and_creates_those_without_ids(): void
{
[$tenant] = $this->configuredTenant();
Sanctum::actingAs($this->createAdminAppUser($tenant));
$created = $this->postJson('/api/v1/adminapp/tenant/merchandise', [
'items' => [
$this->itemPayload('Camiseta', 3, [
$this->variantPayload('Verde', 'S', 100, 10000),
]),
],
])->assertOk();
$itemId = $created->json('data.0.id');
$variantId = $created->json('data.0.variants.0.id');
$updatedVariant = $this->variantPayload('Blanco', 'M', 80, 12500);
$updatedVariant['id'] = $variantId;
$updatedItem = $this->itemPayload('Camiseta oficial', 2, [
$updatedVariant,
$this->variantPayload('Verde', 'L', 60, 15000),
]);
$updatedItem['id'] = $itemId;
$this->postJson('/api/v1/adminapp/tenant/merchandise', [
'items' => [$updatedItem],
])
->assertOk()
->assertJsonPath('data.0.id', $itemId)
->assertJsonPath('data.0.title', 'Camiseta oficial')
->assertJsonPath('data.0.max_units_per_user', 2)
->assertJsonPath('data.0.variants.0.id', $variantId)
->assertJsonPath('data.0.variants.0.color', 'Blanco')
->assertJsonPath('data.0.variants.0.size', 'M')
->assertJsonPath('data.0.variants.0.stock', 80)
->assertJsonCount(2, 'data.0.variants');
$this->assertDatabaseCount('catalog_items', 1);
$this->assertDatabaseCount('variantes', 2);
$this->assertDatabaseHas('catalog_items', [
'id' => $itemId,
'nombre' => 'Camiseta oficial',
'precio' => 12500,
'max_units_per_user' => 2,
]);
}
public function test_it_deletes_merchandise_records_and_removes_the_empty_item(): void
{
[$tenant] = $this->configuredTenant();
Sanctum::actingAs($this->createAdminAppUser($tenant));
$created = $this->postJson('/api/v1/adminapp/tenant/merchandise', [
'items' => [
$this->itemPayload('Camiseta', 3, [
$this->variantPayload('Verde', 'S', 100, 10000),
$this->variantPayload('Blanco', 'M', 50, 15000),
]),
],
])->assertOk();
$itemId = $created->json('data.0.id');
$firstId = $created->json('data.0.variants.0.id');
$secondId = $created->json('data.0.variants.1.id');
$this->deleteJson("/api/v1/adminapp/tenant/merchandise/{$firstId}")
->assertNoContent();
$this->assertDatabaseHas('catalog_items', [
'id' => $itemId,
'precio' => 15000,
]);
$this->assertDatabaseCount('variantes', 1);
$this->deleteJson("/api/v1/adminapp/tenant/merchandise/{$secondId}")
->assertNoContent();
$this->assertDatabaseMissing('catalog_items', ['id' => $itemId]);
$this->assertDatabaseCount('variantes', 0);
$this->assertDatabaseCount('inventories', 0);
}
public function test_it_rejects_duplicate_color_and_size_combinations(): void
{
[$tenant] = $this->configuredTenant();
Sanctum::actingAs($this->createAdminAppUser($tenant));
$this->postJson('/api/v1/adminapp/tenant/merchandise', [
'items' => [
$this->itemPayload('Camiseta', 3, [
$this->variantPayload('Verde', 'S', 100, 10000),
$this->variantPayload(' verde ', 's', 50, 12000),
]),
],
])
->assertUnprocessable()
->assertJsonValidationErrors('items.0.variants.1');
$this->assertDatabaseCount('catalog_items', 0);
}
public function test_it_rejects_sizes_that_are_not_attribute_options(): void
{
[$tenant] = $this->configuredTenant();
Sanctum::actingAs($this->createAdminAppUser($tenant));
$this->postJson('/api/v1/adminapp/tenant/merchandise', [
'items' => [
$this->itemPayload('Gorra', 2, [
$this->variantPayload('Verde', 'Único', 100, 10000),
]),
],
])
->assertUnprocessable()
->assertJsonValidationErrors('items.0.variants.0.size');
$this->assertDatabaseCount('catalog_items', 0);
}
public function test_a_variant_id_must_belong_to_its_merchandise_item(): void
{
[$tenant] = $this->configuredTenant();
Sanctum::actingAs($this->createAdminAppUser($tenant));
$created = $this->postJson('/api/v1/adminapp/tenant/merchandise', [
'items' => [
$this->itemPayload('Camiseta', 3, [
$this->variantPayload('Verde', 'S', 100, 10000),
]),
$this->itemPayload('Buzo', 2, [
$this->variantPayload('Blanco', 'M', 50, 20000),
]),
],
])->assertOk();
$firstItemId = $created->json('data.0.id');
$secondItemVariantId = $created->json('data.1.variants.0.id');
$foreignVariant = $this->variantPayload('Azul Marino', 'XL', 20, 30000);
$foreignVariant['id'] = $secondItemVariantId;
$firstItem = $this->itemPayload('Camiseta', 3, [$foreignVariant]);
$firstItem['id'] = $firstItemId;
$this->postJson('/api/v1/adminapp/tenant/merchandise', [
'items' => [$firstItem],
])
->assertUnprocessable()
->assertJsonValidationErrors('items.0.variants.0.id');
$this->assertDatabaseMissing('attribute_options', ['value' => 'azul_marino']);
}
/** @return array{Tenant, Attribute, Attribute} */
private function configuredTenant(): array
{
$headerLogo = $this->attachment('header.png');
$footerLogo = $this->attachment('footer.png');
$tenant = Tenant::query()->create([
'codigo' => 'fiesta_futbol_infantil',
'nombre' => 'Fiesta Fútbol Infantil',
'dominio' => 'fiesta.test',
'primary_color' => '#112233',
'secondary_color' => '#445566',
'danger_color' => '#cc0000',
'header_bg_color' => '#ffffff',
'footer_bg_color' => '#111111',
'header_logo_id' => $headerLogo->id,
'footer_logo_id' => $footerLogo->id,
'website_type_code' => 'onticket',
]);
$colorAttribute = Attribute::query()->create([
'tenant_codigo' => $tenant->codigo,
'codigo' => 'color',
'nombre' => 'Color',
'type' => FieldType::Select,
'is_required' => true,
]);
$colorAttribute->options()->createMany([
['value' => 'Verde', 'label' => 'Verde', 'sort_order' => 1],
['value' => 'Blanco', 'label' => 'Blanco', 'sort_order' => 2],
]);
$sizeAttribute = Attribute::query()->create([
'tenant_codigo' => $tenant->codigo,
'codigo' => 'talle',
'nombre' => 'Talle',
'type' => FieldType::Select,
'is_required' => true,
]);
$sizeAttribute->options()->createMany([
['value' => 'S', 'label' => 'S', 'sort_order' => 1],
['value' => 'M', 'label' => 'M', 'sort_order' => 2],
['value' => 'L', 'label' => 'L', 'sort_order' => 3],
['value' => 'XL', 'label' => 'XL', 'sort_order' => 4],
]);
$menu = Menu::query()->create([
'code' => 'adminapp.fiesta-futbol-infantil.merchandising',
'label' => 'Merchandising',
'route' => '/admin/merchandising',
]);
$tenant->menues()->attach($menu->code);
return [$tenant, $colorAttribute, $sizeAttribute];
}
private function attachment(string $filename): Attachment
{
return Attachment::query()->create([
'path' => "test/{$filename}",
'filename' => $filename,
'type' => AttachmentType::Image,
'mime_type' => 'image/png',
]);
}
/**
* @param array<int, array<string, mixed>> $variants
* @return array<string, mixed>
*/
private function itemPayload(string $title, int $limit, array $variants): array
{
return [
'title' => $title,
'description' => null,
'max_units_per_user' => $limit,
'variants' => $variants,
];
}
/** @return array<string, mixed> */
private function variantPayload(
string $color,
string $size,
int $stock,
float $price,
): array {
return [
'color' => $color,
'size' => $size,
'stock' => $stock,
'price' => $price,
];
}
private function createAdminAppUser(Tenant $tenant): User
{
return User::factory()->create([
'rol_codigo' => RoleCode::AdminApp->value,
'tenant_codigo' => $tenant->codigo,
]);
}
}