Open-source event management and ticket selling platform — perfect for concerts, conferences, and everything in between 🎟️ If you find this project helpful, please consider giving us a star ⭐️
PHP attendize-alternativedoor-managementevent-check-inevent-managementevent-registrationevent-ticketingeventbrite-alternativeeventslaravelopen-sourcephpreactself-hostedsell-ticketssell-tickets-onlineticket-sellingticketing-systemtickettailor-alternativetito-alternative
Feature: Dashboard e2e tests (#1321)
Dave Earley5e8d2d354a6d
diff --git a/backend/tests/Unit/Services/Application/Handlers/Attendee/CreateAttendeeHandlerTest.php b/backend/tests/Unit/Services/Application/Handlers/Attendee/CreateAttendeeHandlerTest.phpnew file mode 100644index 000000000..2a66b1c3d--- /dev/null+++ b/backend/tests/Unit/Services/Application/Handlers/Attendee/CreateAttendeeHandlerTest.php@@ -0,0 +1,363 @@+<?php++namespace Tests\Unit\Services\Application\Handlers\Attendee;++use HiEvents\DomainObjects\AttendeeDomainObject;+use HiEvents\DomainObjects\Enums\EventType;+use HiEvents\DomainObjects\Enums\ProductType;+use HiEvents\DomainObjects\EventDomainObject;+use HiEvents\DomainObjects\EventOccurrenceDomainObject;+use HiEvents\DomainObjects\Generated\AttendeeDomainObjectAbstract;+use HiEvents\DomainObjects\Generated\OrderDomainObjectAbstract;+use HiEvents\DomainObjects\Generated\OrderItemDomainObjectAbstract;+use HiEvents\DomainObjects\Generated\ProductDomainObjectAbstract;+use HiEvents\DomainObjects\OrderDomainObject;+use HiEvents\DomainObjects\OrderItemDomainObject;+use HiEvents\DomainObjects\ProductDomainObject;+use HiEvents\DomainObjects\ProductPriceDomainObject;+use HiEvents\DomainObjects\Status\AttendeeStatus;+use HiEvents\DomainObjects\Status\OrderPaymentStatus;+use HiEvents\DomainObjects\Status\OrderStatus;+use HiEvents\Events\OrderStatusChangedEvent;+use HiEvents\Exceptions\InvalidProductPriceId;+use HiEvents\Exceptions\NoTicketsAvailableException;+use HiEvents\Repository\Interfaces\AttendeeRepositoryInterface;+use HiEvents\Repository\Interfaces\EventOccurrenceRepositoryInterface;+use HiEvents\Repository\Interfaces\EventRepositoryInterface;+use HiEvents\Repository\Interfaces\OrderRepositoryInterface;+use HiEvents\Repository\Interfaces\ProductRepositoryInterface;+use HiEvents\Repository\Interfaces\TaxAndFeeRepositoryInterface;+use HiEvents\Services\Application\Handlers\Attendee\CreateAttendeeHandler;+use HiEvents\Services\Application\Handlers\Attendee\DTO\CreateAttendeeDTO;+use HiEvents\Services\Domain\EventOccurrence\OccurrencePurchaseEligibilityService;+use HiEvents\Services\Domain\Order\OrderManagementService;+use HiEvents\Services\Domain\Product\ProductQuantityUpdateService;+use HiEvents\Services\Domain\SelfService\OrderAuditLogService;+use HiEvents\Services\Domain\Tax\TaxAndFeeRollupService;+use HiEvents\Services\Infrastructure\DomainEvents\DomainEventDispatcherService;+use HiEvents\Services\Infrastructure\DomainEvents\Enums\DomainEventType;+use HiEvents\Services\Infrastructure\DomainEvents\Events\OrderEvent;+use Illuminate\Database\DatabaseManager;+use Illuminate\Support\Facades\Event;+use Illuminate\Validation\ValidationException;+use Mockery;+use Mockery\MockInterface;+use Tests\TestCase;++class CreateAttendeeHandlerTest extends TestCase+{+ private const EVENT_ID = 10;++ private const ORDER_ID = 20;++ private const ATTENDEE_ID = 30;++ private const PRODUCT_ID = 40;++ private const PRODUCT_PRICE_ID = 41;++ private const OCCURRENCE_ID = 50;++ private AttendeeRepositoryInterface|MockInterface $attendeeRepository;++ private OrderRepositoryInterface|MockInterface $orderRepository;++ private ProductRepositoryInterface|MockInterface $productRepository;++ private EventRepositoryInterface|MockInterface $eventRepository;++ private EventOccurrenceRepositoryInterface|MockInterface $occurrenceRepository;++ private ProductQuantityUpdateService|MockInterface $productQuantityService;++ private OrderManagementService|MockInterface $orderManagementService;++ private DomainEventDispatcherService|MockInterface $domainEventDispatcherService;++ private OccurrencePurchaseEligibilityService|MockInterface $occurrenceEligibilityService;++ private OrderAuditLogService|MockInterface $orderAuditLogService;++ private CreateAttendeeHandler $handler;++ protected function setUp(): void+ {+ parent::setUp();+ Event::fake();++ $this->attendeeRepository = Mockery::mock(AttendeeRepositoryInterface::class);+ $this->orderRepository = Mockery::mock(OrderRepositoryInterface::class);+ $this->productRepository = Mockery::mock(ProductRepositoryInterface::class);+ $this->eventRepository = Mockery::mock(EventRepositoryInterface::class);+ $this->occurrenceRepository = Mockery::mock(EventOccurrenceRepositoryInterface::class);+ $this->productQuantityService = Mockery::mock(ProductQuantityUpdateService::class);+ $this->orderManagementService = Mockery::mock(OrderManagementService::class);+ $this->domainEventDispatcherService = Mockery::mock(DomainEventDispatcherService::class);+ $this->occurrenceEligibilityService = Mockery::mock(OccurrencePurchaseEligibilityService::class);+ $this->orderAuditLogService = Mockery::mock(OrderAuditLogService::class);++ $databaseManager = Mockery::mock(DatabaseManager::class);+ $databaseManager->shouldReceive('transaction')->andReturnUsing(fn (callable $callback) => $callback());++ $this->productRepository->shouldReceive('loadRelation')->andReturnSelf();++ $this->handler = new CreateAttendeeHandler(+ $this->attendeeRepository,+ $this->orderRepository,+ $this->productRepository,+ $this->eventRepository,+ $this->occurrenceRepository,+ $this->productQuantityService,+ $databaseManager,+ Mockery::mock(TaxAndFeeRepositoryInterface::class),+ new TaxAndFeeRollupService,+ $this->orderManagementService,+ $this->domainEventDispatcherService,+ $this->occurrenceEligibilityService,+ $this->orderAuditLogService,+ );+ }++ public function test_a_manual_attendee_creates_a_completed_order_and_fires_the_completion_event(): void+ {+ $this->givenSingleEvent();+ $this->givenOccurrenceIsPurchasable();+ $this->givenTicketProduct();+ $this->productRepository->shouldReceive('getQuantityRemainingForProductPrice')+ ->once()->with(self::PRODUCT_ID, self::PRODUCT_PRICE_ID)->andReturn(5);++ $this->orderRepository->shouldReceive('create')+ ->once()+ ->withArgs(fn (array $attributes): bool => $attributes[OrderDomainObjectAbstract::STATUS] === OrderStatus::COMPLETED->name+ && $attributes[OrderDomainObjectAbstract::PAYMENT_STATUS] === OrderPaymentStatus::PAYMENT_RECEIVED->name+ && $attributes[OrderDomainObjectAbstract::TOTAL_GROSS] === 25.0+ && $attributes[OrderDomainObjectAbstract::EVENT_ID] === self::EVENT_ID+ && $attributes[OrderDomainObjectAbstract::IS_MANUALLY_CREATED] === true+ && $attributes[OrderDomainObjectAbstract::CURRENCY] === 'USD')+ ->andReturn($this->order());++ $this->orderRepository->shouldReceive('addOrderItem')+ ->once()+ ->withArgs(fn (array $attributes): bool => $attributes[OrderItemDomainObjectAbstract::QUANTITY] === 1+ && $attributes[OrderItemDomainObjectAbstract::PRODUCT_PRICE_ID] === self::PRODUCT_PRICE_ID+ && $attributes[OrderItemDomainObjectAbstract::PRODUCT_TYPE] === ProductType::TICKET->name+ && $attributes[OrderItemDomainObjectAbstract::EVENT_OCCURRENCE_ID] === self::OCCURRENCE_ID+ && $attributes[OrderItemDomainObjectAbstract::TOTAL_GROSS] === 25.0)+ ->andReturn(new OrderItemDomainObject);++ $this->attendeeRepository->shouldReceive('create')+ ->once()+ ->withArgs(fn (array $attributes): bool => $attributes[AttendeeDomainObjectAbstract::STATUS] === AttendeeStatus::ACTIVE->name+ && $attributes[AttendeeDomainObjectAbstract::ORDER_ID] === self::ORDER_ID+ && $attributes[AttendeeDomainObjectAbstract::PRODUCT_PRICE_ID] === self::PRODUCT_PRICE_ID+ && $attributes[AttendeeDomainObjectAbstract::EVENT_OCCURRENCE_ID] === self::OCCURRENCE_ID)+ ->andReturn((new AttendeeDomainObject)->setId(self::ATTENDEE_ID));++ $this->orderManagementService->shouldReceive('updateOrderTotals')->once()->andReturn($this->order());++ $this->productQuantityService->shouldReceive('increaseQuantitySold')+ ->once()+ ->with(self::PRODUCT_PRICE_ID, 1, self::OCCURRENCE_ID);++ $this->domainEventDispatcherService->shouldReceive('dispatch')+ ->once()+ ->with(Mockery::on(fn (OrderEvent $event) => $event->type === DomainEventType::ORDER_CREATED+ && $event->orderId === self::ORDER_ID));++ $this->orderAuditLogService->shouldNotReceive('logManualAttendeeCapacityOverride');++ $attendee = $this->handler->handle($this->dto(amountPaid: 25, occurrenceId: self::OCCURRENCE_ID));++ $this->assertSame(self::ATTENDEE_ID, $attendee->getId());++ Event::assertDispatched(+ OrderStatusChangedEvent::class,+ fn (OrderStatusChangedEvent $event) => $event->order->getId() === self::ORDER_ID+ && $event->order->isOrderCompleted()+ && $event->sendEmails === true+ );+ }++ public function test_a_single_event_resolves_its_only_occurrence_when_none_is_given(): void+ {+ $this->givenSingleEvent();+ $this->occurrenceRepository->shouldReceive('findFirstWhere')+ ->once()+ ->with(['event_id' => self::EVENT_ID])+ ->andReturn((new EventOccurrenceDomainObject)->setId(self::OCCURRENCE_ID));+ $this->givenOccurrenceIsPurchasable();+ $this->givenTicketProduct();+ $this->givenHappyPathPersistence();++ $this->productQuantityService->shouldReceive('increaseQuantitySold')+ ->once()+ ->with(self::PRODUCT_PRICE_ID, 1, self::OCCURRENCE_ID);++ $this->handler->handle($this->dto(amountPaid: 0, occurrenceId: null));++ Event::assertDispatched(OrderStatusChangedEvent::class);+ }++ public function test_a_recurring_event_requires_an_occurrence(): void+ {+ $this->eventRepository->shouldReceive('findById')+ ->once()+ ->with(self::EVENT_ID)+ ->andReturn((new EventDomainObject)->setId(self::EVENT_ID)->setType(EventType::RECURRING->name)->setCurrency('USD'));++ $this->occurrenceRepository->shouldNotReceive('findFirstWhere');+ $this->orderRepository->shouldNotReceive('create');++ $this->expectException(ValidationException::class);++ $this->handler->handle($this->dto(amountPaid: 0, occurrenceId: null));+ }++ public function test_a_free_manual_attendee_requires_no_payment(): void+ {+ $this->givenSingleEvent();+ $this->givenOccurrenceIsPurchasable();+ $this->givenTicketProduct();+ $this->givenHappyPathPersistence(expectedPaymentStatus: OrderPaymentStatus::NO_PAYMENT_REQUIRED);+ $this->productQuantityService->shouldReceive('increaseQuantitySold')->once();++ $this->handler->handle($this->dto(amountPaid: 0, occurrenceId: self::OCCURRENCE_ID));+ }++ public function test_no_attendee_is_created_when_the_product_is_sold_out(): void+ {+ $this->givenSingleEvent();+ $this->givenOccurrenceIsPurchasable();+ $this->givenTicketProduct();+ $this->orderRepository->shouldReceive('create')->once()->andReturn($this->order());+ $this->productRepository->shouldReceive('getQuantityRemainingForProductPrice')->once()->andReturn(0);++ $this->attendeeRepository->shouldNotReceive('create');+ $this->productQuantityService->shouldNotReceive('increaseQuantitySold');++ $this->expectException(NoTicketsAvailableException::class);++ try {+ $this->handler->handle($this->dto(amountPaid: 10, occurrenceId: self::OCCURRENCE_ID));+ } finally {+ Event::assertNotDispatched(OrderStatusChangedEvent::class);+ }+ }++ public function test_a_price_that_does_not_belong_to_the_product_is_rejected(): void+ {+ $this->givenSingleEvent();+ $this->givenOccurrenceIsPurchasable();+ $this->givenTicketProduct();+ $this->orderRepository->shouldReceive('create')->once()->andReturn($this->order());++ $this->attendeeRepository->shouldNotReceive('create');+ $this->productQuantityService->shouldNotReceive('increaseQuantitySold');++ $this->expectException(InvalidProductPriceId::class);++ $this->handler->handle($this->dto(amountPaid: 10, occurrenceId: self::OCCURRENCE_ID, productPriceId: 999));+ }++ public function test_a_capacity_override_is_audit_logged(): void+ {+ $this->givenSingleEvent();+ $this->occurrenceEligibilityService->shouldReceive('assertOccurrencePurchasable')+ ->once()+ ->withArgs(fn (int $eventId, int $occurrenceId, int $additionalQuantity, bool $overrideCapacity): bool => $overrideCapacity === true);+ $this->occurrenceEligibilityService->shouldReceive('assertProductsVisibleOnOccurrence')->once();+ $this->givenTicketProduct();+ $this->givenHappyPathPersistence();+ $this->productQuantityService->shouldReceive('increaseQuantitySold')->once();++ $this->orderAuditLogService->shouldReceive('logManualAttendeeCapacityOverride')+ ->once()+ ->with(self::EVENT_ID, self::ORDER_ID, self::ATTENDEE_ID, self::OCCURRENCE_ID, '10.0.0.1', 'agent');++ $this->handler->handle($this->dto(amountPaid: 0, occurrenceId: self::OCCURRENCE_ID, overrideCapacity: true));+ }++ private function dto(+ float $amountPaid,+ ?int $occurrenceId,+ ?int $productPriceId = self::PRODUCT_PRICE_ID,+ bool $overrideCapacity = false,+ ): CreateAttendeeDTO {+ return new CreateAttendeeDTO(+ first_name: 'Manual',+ last_name: 'Attendee',+ email: '[email protected]',+ product_id: self::PRODUCT_ID,+ event_id: self::EVENT_ID,+ send_confirmation_email: true,+ amount_paid: $amountPaid,+ locale: 'en',+ product_price_id: $productPriceId,+ event_occurrence_id: $occurrenceId,+ override_capacity: $overrideCapacity,+ client_ip: '10.0.0.1',+ client_user_agent: 'agent',+ );+ }++ private function order(): OrderDomainObject+ {+ return (new OrderDomainObject)+ ->setId(self::ORDER_ID)+ ->setEventId(self::EVENT_ID)+ ->setStatus(OrderStatus::COMPLETED->name)+ ->setCurrency('USD');+ }++ private function givenSingleEvent(): void+ {+ $this->eventRepository->shouldReceive('findById')+ ->with(self::EVENT_ID)+ ->andReturn((new EventDomainObject)->setId(self::EVENT_ID)->setType(EventType::SINGLE->name)->setCurrency('USD'));+ }++ private function givenOccurrenceIsPurchasable(): void+ {+ $this->occurrenceEligibilityService->shouldReceive('assertOccurrencePurchasable')+ ->once()+ ->withArgs(fn (int $eventId, int $occurrenceId, int $additionalQuantity, bool $overrideCapacity): bool => $eventId === self::EVENT_ID+ && $occurrenceId === self::OCCURRENCE_ID+ && $additionalQuantity === 1+ && $overrideCapacity === false);+ $this->occurrenceEligibilityService->shouldReceive('assertProductsVisibleOnOccurrence')+ ->once()+ ->with(self::OCCURRENCE_ID, [self::PRODUCT_ID]);+ }++ private function givenTicketProduct(): void+ {+ $product = (new ProductDomainObject)+ ->setId(self::PRODUCT_ID)+ ->setTitle('General Admission')+ ->setProductType(ProductType::TICKET->name)+ ->setProductPrices(collect([(new ProductPriceDomainObject)->setId(self::PRODUCT_PRICE_ID)]));++ $this->productRepository->shouldReceive('findFirstWhere')+ ->once()+ ->with([+ ProductDomainObjectAbstract::ID => self::PRODUCT_ID,+ ProductDomainObjectAbstract::EVENT_ID => self::EVENT_ID,+ ProductDomainObjectAbstract::PRODUCT_TYPE => ProductType::TICKET->name,+ ])+ ->andReturn($product);+ }++ private function givenHappyPathPersistence(+ OrderPaymentStatus $expectedPaymentStatus = OrderPaymentStatus::NO_PAYMENT_REQUIRED,+ ): void {+ $this->productRepository->shouldReceive('getQuantityRemainingForProductPrice')->once()->andReturn(5);+ $this->orderRepository->shouldReceive('create')+ ->once()+ ->withArgs(fn (array $attributes): bool => $attributes[OrderDomainObjectAbstract::PAYMENT_STATUS] === $expectedPaymentStatus->name)+ ->andReturn($this->order());+ $this->orderRepository->shouldReceive('addOrderItem')->once()->andReturn(new OrderItemDomainObject);+ $this->attendeeRepository->shouldReceive('create')->once()->andReturn((new AttendeeDomainObject)->setId(self::ATTENDEE_ID));+ $this->orderManagementService->shouldReceive('updateOrderTotals')->once()->andReturn($this->order());+ $this->domainEventDispatcherService->shouldReceive('dispatch')->once();+ }+}diff --git a/backend/tests/Unit/Services/Application/Handlers/Attendee/PartialEditAttendeeHandlerTest.php b/backend/tests/Unit/Services/Application/Handlers/Attendee/PartialEditAttendeeHandlerTest.phpnew file mode 100644index 000000000..008ee8836--- /dev/null+++ b/backend/tests/Unit/Services/Application/Handlers/Attendee/PartialEditAttendeeHandlerTest.php@@ -0,0 +1,287 @@+<?php++namespace Tests\Unit\Services\Application\Handlers\Attendee;++use HiEvents\DomainObjects\AttendeeDomainObject;+use HiEvents\DomainObjects\Enums\CapacityChangeDirection;+use HiEvents\DomainObjects\OrderDomainObject;+use HiEvents\DomainObjects\Status\AttendeeStatus;+use HiEvents\Events\CapacityChangedEvent;+use HiEvents\Repository\Interfaces\AttendeeRepositoryInterface;+use HiEvents\Repository\Interfaces\OrderRepositoryInterface;+use HiEvents\Services\Application\Handlers\Attendee\DTO\PartialEditAttendeeDTO;+use HiEvents\Services\Application\Handlers\Attendee\PartialEditAttendeeHandler;+use HiEvents\Services\Domain\EventStatistics\EventStatisticsCancellationService;+use HiEvents\Services\Domain\EventStatistics\EventStatisticsReactivationService;+use HiEvents\Services\Domain\Product\ProductQuantityUpdateService;+use HiEvents\Services\Infrastructure\DomainEvents\DomainEventDispatcherService;+use HiEvents\Services\Infrastructure\DomainEvents\Enums\DomainEventType;+use HiEvents\Services\Infrastructure\DomainEvents\Events\AttendeeEvent;+use Illuminate\Database\DatabaseManager;+use Illuminate\Support\Facades\Event;+use Mockery;+use Mockery\MockInterface;+use Psr\Log\LoggerInterface;+use Symfony\Component\Routing\Exception\ResourceNotFoundException;+use Tests\TestCase;++class PartialEditAttendeeHandlerTest extends TestCase+{+ private const EVENT_ID = 10;++ private const ORDER_ID = 20;++ private const ATTENDEE_ID = 30;++ private const PRODUCT_ID = 40;++ private const PRODUCT_PRICE_ID = 41;++ private const OCCURRENCE_ID = 50;++ private const ORDER_CREATED_AT = '2026-08-20 10:00:00';++ private AttendeeRepositoryInterface|MockInterface $attendeeRepository;++ private OrderRepositoryInterface|MockInterface $orderRepository;++ private ProductQuantityUpdateService|MockInterface $productQuantityService;++ private DomainEventDispatcherService|MockInterface $domainEventDispatcherService;++ private EventStatisticsCancellationService|MockInterface $cancellationService;++ private EventStatisticsReactivationService|MockInterface $reactivationService;++ private PartialEditAttendeeHandler $handler;++ protected function setUp(): void+ {+ parent::setUp();+ Event::fake();++ $this->attendeeRepository = Mockery::mock(AttendeeRepositoryInterface::class);+ $this->orderRepository = Mockery::mock(OrderRepositoryInterface::class);+ $this->productQuantityService = Mockery::mock(ProductQuantityUpdateService::class);+ $this->domainEventDispatcherService = Mockery::mock(DomainEventDispatcherService::class);+ $this->cancellationService = Mockery::mock(EventStatisticsCancellationService::class);+ $this->reactivationService = Mockery::mock(EventStatisticsReactivationService::class);++ $databaseManager = Mockery::mock(DatabaseManager::class);+ $databaseManager->shouldReceive('transaction')->andReturnUsing(fn (callable $callback) => $callback());++ $this->handler = new PartialEditAttendeeHandler(+ $this->attendeeRepository,+ $this->orderRepository,+ $this->productQuantityService,+ $databaseManager,+ $this->domainEventDispatcherService,+ $this->cancellationService,+ $this->reactivationService,+ Mockery::mock(LoggerInterface::class)->shouldIgnoreMissing(),+ );+ }++ public function test_cancelling_an_active_attendee_releases_capacity_and_decrements_statistics(): void+ {+ $this->givenAttendee(AttendeeStatus::ACTIVE);+ $this->givenOrderExists();+ $this->expectAttendeeUpdatedWithStatus(AttendeeStatus::CANCELLED);++ $this->productQuantityService->shouldReceive('decreaseQuantitySold')+ ->once()+ ->with(self::PRODUCT_PRICE_ID, 1, self::OCCURRENCE_ID);+ $this->productQuantityService->shouldNotReceive('increaseQuantitySold');++ $this->cancellationService->shouldReceive('decrementForCancelledAttendee')+ ->once()+ ->with(self::EVENT_ID, self::ORDER_CREATED_AT, 1, self::OCCURRENCE_ID);+ $this->reactivationService->shouldNotReceive('incrementForReactivatedAttendee');++ $this->domainEventDispatcherService->shouldReceive('dispatch')+ ->once()+ ->with(Mockery::on(+ fn (AttendeeEvent $event) => $event->type === DomainEventType::ATTENDEE_CANCELLED+ && $event->attendeeId === self::ATTENDEE_ID+ ));++ $this->handler->handle($this->dto(AttendeeStatus::CANCELLED));++ Event::assertDispatched(+ CapacityChangedEvent::class,+ fn (CapacityChangedEvent $event) => $event->direction === CapacityChangeDirection::INCREASED+ && $event->eventId === self::EVENT_ID+ && $event->productPriceId === self::PRODUCT_PRICE_ID+ && $event->eventOccurrenceId === self::OCCURRENCE_ID+ );+ }++ public function test_reactivating_a_cancelled_attendee_consumes_capacity_and_increments_statistics(): void+ {+ $this->givenAttendee(AttendeeStatus::CANCELLED);+ $this->givenOrderExists();+ $this->expectAttendeeUpdatedWithStatus(AttendeeStatus::ACTIVE);++ $this->productQuantityService->shouldReceive('increaseQuantitySold')+ ->once()+ ->with(self::PRODUCT_PRICE_ID, 1, self::OCCURRENCE_ID);+ $this->productQuantityService->shouldNotReceive('decreaseQuantitySold');++ $this->reactivationService->shouldReceive('incrementForReactivatedAttendee')+ ->once()+ ->with(self::EVENT_ID, self::ORDER_CREATED_AT, 1, self::OCCURRENCE_ID);+ $this->cancellationService->shouldNotReceive('decrementForCancelledAttendee');+ $this->domainEventDispatcherService->shouldNotReceive('dispatch');++ $this->handler->handle($this->dto(AttendeeStatus::ACTIVE));++ Event::assertDispatched(+ CapacityChangedEvent::class,+ fn (CapacityChangedEvent $event) => $event->direction === CapacityChangeDirection::DECREASED+ && $event->productPriceId === self::PRODUCT_PRICE_ID+ && $event->eventOccurrenceId === self::OCCURRENCE_ID+ );+ }++ public function test_setting_the_same_status_does_not_touch_capacity_or_statistics(): void+ {+ $this->givenAttendee(AttendeeStatus::ACTIVE);+ $this->expectAttendeeUpdatedWithStatus(AttendeeStatus::ACTIVE);++ $this->productQuantityService->shouldNotReceive('increaseQuantitySold');+ $this->productQuantityService->shouldNotReceive('decreaseQuantitySold');+ $this->cancellationService->shouldNotReceive('decrementForCancelledAttendee');+ $this->reactivationService->shouldNotReceive('incrementForReactivatedAttendee');+ $this->domainEventDispatcherService->shouldNotReceive('dispatch');+ $this->orderRepository->shouldNotReceive('findFirstWhere');++ $this->handler->handle($this->dto(AttendeeStatus::ACTIVE));++ Event::assertNotDispatched(CapacityChangedEvent::class);+ }++ public function test_editing_only_contact_details_does_not_touch_capacity_or_statistics(): void+ {+ $this->givenAttendee(AttendeeStatus::ACTIVE);++ $this->attendeeRepository->shouldReceive('updateByIdWhere')+ ->once()+ ->withArgs(function (int $id, array $attributes, array $where): bool {+ return $id === self::ATTENDEE_ID+ && $attributes['status'] === AttendeeStatus::ACTIVE->name+ && $attributes['first_name'] === 'Renamed'+ && $attributes['last_name'] === 'Last'+ && $attributes['email'] === '[email protected]'+ && $where === ['event_id' => self::EVENT_ID];+ })+ ->andReturn(new AttendeeDomainObject);++ $this->productQuantityService->shouldNotReceive('increaseQuantitySold');+ $this->productQuantityService->shouldNotReceive('decreaseQuantitySold');+ $this->cancellationService->shouldNotReceive('decrementForCancelledAttendee');+ $this->reactivationService->shouldNotReceive('incrementForReactivatedAttendee');++ $this->handler->handle(new PartialEditAttendeeDTO(+ attendee_id: self::ATTENDEE_ID,+ event_id: self::EVENT_ID,+ first_name: 'Renamed',+ last_name: null,+ email: null,+ status: null,+ ));++ Event::assertNotDispatched(CapacityChangedEvent::class);+ }++ public function test_cancelling_an_attendee_without_an_occurrence_decrements_event_level_statistics_only(): void+ {+ $this->givenAttendee(AttendeeStatus::ACTIVE, occurrenceId: null);+ $this->givenOrderExists();+ $this->expectAttendeeUpdatedWithStatus(AttendeeStatus::CANCELLED);++ $this->productQuantityService->shouldReceive('decreaseQuantitySold')+ ->once()+ ->with(self::PRODUCT_PRICE_ID, 1, null);+ $this->cancellationService->shouldReceive('decrementForCancelledAttendee')+ ->once()+ ->with(self::EVENT_ID, self::ORDER_CREATED_AT, 1, null);+ $this->domainEventDispatcherService->shouldReceive('dispatch')->once();++ $this->handler->handle($this->dto(AttendeeStatus::CANCELLED));+ }++ public function test_capacity_is_still_released_when_the_order_cannot_be_found(): void+ {+ $this->givenAttendee(AttendeeStatus::ACTIVE);+ $this->orderRepository->shouldReceive('findFirstWhere')->once()->andReturnNull();+ $this->expectAttendeeUpdatedWithStatus(AttendeeStatus::CANCELLED);++ $this->productQuantityService->shouldReceive('decreaseQuantitySold')->once();+ $this->cancellationService->shouldNotReceive('decrementForCancelledAttendee');+ $this->domainEventDispatcherService->shouldReceive('dispatch')->once();++ $this->handler->handle($this->dto(AttendeeStatus::CANCELLED));+ }++ public function test_throws_when_attendee_does_not_belong_to_event(): void+ {+ $this->attendeeRepository->shouldReceive('findFirstWhere')+ ->once()+ ->with(['id' => self::ATTENDEE_ID, 'event_id' => self::EVENT_ID])+ ->andReturnNull();++ $this->expectException(ResourceNotFoundException::class);++ $this->handler->handle($this->dto(AttendeeStatus::CANCELLED));+ }++ private function dto(AttendeeStatus $status): PartialEditAttendeeDTO+ {+ return new PartialEditAttendeeDTO(+ attendee_id: self::ATTENDEE_ID,+ event_id: self::EVENT_ID,+ first_name: null,+ last_name: null,+ email: null,+ status: $status->name,+ );+ }++ private function givenAttendee(AttendeeStatus $status, ?int $occurrenceId = self::OCCURRENCE_ID): void+ {+ $attendee = (new AttendeeDomainObject)+ ->setId(self::ATTENDEE_ID)+ ->setEventId(self::EVENT_ID)+ ->setOrderId(self::ORDER_ID)+ ->setProductId(self::PRODUCT_ID)+ ->setProductPriceId(self::PRODUCT_PRICE_ID)+ ->setEventOccurrenceId($occurrenceId)+ ->setStatus($status->name)+ ->setFirstName('Original')+ ->setLastName('Last')+ ->setEmail('[email protected]');++ $this->attendeeRepository->shouldReceive('findFirstWhere')+ ->once()+ ->with(['id' => self::ATTENDEE_ID, 'event_id' => self::EVENT_ID])+ ->andReturn($attendee);+ }++ private function givenOrderExists(): void+ {+ $this->orderRepository->shouldReceive('findFirstWhere')+ ->once()+ ->with(['id' => self::ORDER_ID, 'event_id' => self::EVENT_ID])+ ->andReturn((new OrderDomainObject)->setId(self::ORDER_ID)->setCreatedAt(self::ORDER_CREATED_AT));+ }++ private function expectAttendeeUpdatedWithStatus(AttendeeStatus $status): void+ {+ $this->attendeeRepository->shouldReceive('updateByIdWhere')+ ->once()+ ->withArgs(fn (int $id, array $attributes, array $where): bool => $id === self::ATTENDEE_ID+ && $attributes['status'] === $status->name+ && $where === ['event_id' => self::EVENT_ID])+ ->andReturn(new AttendeeDomainObject);+ }+}diff --git a/backend/tests/Unit/Services/Domain/EventStatistics/EventStatisticsIncrementServiceTest.php b/backend/tests/Unit/Services/Domain/EventStatistics/EventStatisticsIncrementServiceTest.phpindex 67a12e125..44609f851 100644--- a/backend/tests/Unit/Services/Domain/EventStatistics/EventStatisticsIncrementServiceTest.php+++ b/backend/tests/Unit/Services/Domain/EventStatistics/EventStatisticsIncrementServiceTest.php@@ -2,7 +2,9 @@namespace Tests\Unit\Services\Domain\EventStatistics;+use HiEvents\DomainObjects\Enums\ProductType;use HiEvents\DomainObjects\EventDailyStatisticDomainObject;+use HiEvents\DomainObjects\EventOccurrenceDailyStatisticDomainObject;use HiEvents\DomainObjects\EventStatisticDomainObject;use HiEvents\DomainObjects\Generated\ProductDomainObjectAbstract;use HiEvents\DomainObjects\Generated\PromoCodeDomainObjectAbstract;@@ -36,6 +38,10 @@ class EventStatisticsIncrementServiceTest extends TestCaseprivate MockInterface|EventDailyStatisticRepositoryInterface $eventDailyStatisticRepository;+ private MockInterface|EventOccurrenceStatisticRepositoryInterface $eventOccurrenceStatisticRepository;++ private MockInterface|EventOccurrenceDailyStatisticRepositoryInterface $eventOccurrenceDailyStatisticRepository;+private MockInterface|DatabaseManager $databaseManager;private MockInterface|OrderRepositoryInterface $orderRepository;@@ -52,8 +58,8 @@ class EventStatisticsIncrementServiceTest extends TestCase$this->productRepository = Mockery::mock(ProductRepositoryInterface::class);$this->eventStatisticsRepository = Mockery::mock(EventStatisticRepositoryInterface::class);$this->eventDailyStatisticRepository = Mockery::mock(EventDailyStatisticRepositoryInterface::class);- $eventOccurrenceStatisticRepository = Mockery::mock(EventOccurrenceStatisticRepositoryInterface::class);- $eventOccurrenceDailyStatisticRepository = Mockery::mock(EventOccurrenceDailyStatisticRepositoryInterface::class);+ $this->eventOccurrenceStatisticRepository = Mockery::mock(EventOccurrenceStatisticRepositoryInterface::class);+ $this->eventOccurrenceDailyStatisticRepository = Mockery::mock(EventOccurrenceDailyStatisticRepositoryInterface::class);$this->databaseManager = Mockery::mock(DatabaseManager::class);$this->orderRepository = Mockery::mock(OrderRepositoryInterface::class);$this->logger = Mockery::mock(LoggerInterface::class);@@ -64,8 +70,8 @@ class EventStatisticsIncrementServiceTest extends TestCase$this->productRepository,$this->eventStatisticsRepository,$this->eventDailyStatisticRepository,- $eventOccurrenceStatisticRepository,- $eventOccurrenceDailyStatisticRepository,+ $this->eventOccurrenceStatisticRepository,+ $this->eventOccurrenceDailyStatisticRepository,$this->databaseManager,$this->orderRepository,$this->logger,@@ -367,4 +373,104 @@ class EventStatisticsIncrementServiceTest extends TestCaseMockery::close();parent::tearDown();}++ public function test_add_on_items_count_as_products_sold_but_not_as_attendees(): void+ {+ $eventId = 1;+ $orderId = 321;+ $occurrenceId = 77;++ $ticketItem = (new OrderItemDomainObject)+ ->setProductId(1)+ ->setProductType(ProductType::TICKET->name)+ ->setQuantity(2)+ ->setEventOccurrenceId($occurrenceId)+ ->setTotalBeforeAdditions(100.00)+ ->setTotalGross(110.00)+ ->setTotalTax(8.00)+ ->setTotalServiceFee(2.00);++ $addOnItem = (new OrderItemDomainObject)+ ->setProductId(2)+ ->setProductType(ProductType::GENERAL->name)+ ->setQuantity(1)+ ->setEventOccurrenceId($occurrenceId)+ ->setTotalBeforeAdditions(20.00)+ ->setTotalGross(22.00)+ ->setTotalTax(1.50)+ ->setTotalServiceFee(0.50);++ $order = (new OrderDomainObject)+ ->setId($orderId)+ ->setEventId($eventId)+ ->setCreatedAt('2024-01-15 10:30:00')+ ->setOrderItems(new Collection([$ticketItem, $addOnItem]))+ ->setTotalGross(132.00)+ ->setTotalBeforeAdditions(120.00)+ ->setTotalTax(9.50)+ ->setTotalFee(2.50);++ $this->orderRepository->shouldReceive('loadRelation')->andReturnSelf();+ $this->orderRepository->shouldReceive('findById')->with($orderId)->andReturn($order);+ $this->retrier->shouldReceive('retry')->andReturnUsing(fn ($callableAction) => $callableAction(1));+ $this->databaseManager->shouldReceive('transaction')->andReturnUsing(fn ($callback) => $callback());+ $this->logger->shouldReceive('info');++ $this->eventStatisticsRepository->shouldReceive('findFirstWhere')->andReturnNull();+ $this->eventStatisticsRepository->shouldReceive('create')+ ->once()+ ->withArgs(fn (array $attributes): bool => $attributes['products_sold'] === 3+ && $attributes['attendees_registered'] === 2+ && $attributes['sales_total_gross'] === 132.00+ && $attributes['orders_created'] === 1);++ $this->eventDailyStatisticRepository->shouldReceive('findFirstWhere')->andReturnNull();+ $this->eventDailyStatisticRepository->shouldReceive('create')+ ->once()+ ->withArgs(fn (array $attributes): bool => $attributes['products_sold'] === 3+ && $attributes['attendees_registered'] === 2+ && $attributes['date'] === '2024-01-15');++ $this->eventOccurrenceStatisticRepository->shouldReceive('findFirstWhere')+ ->with(['event_id' => $eventId, 'event_occurrence_id' => $occurrenceId])+ ->andReturnNull();+ $this->eventOccurrenceStatisticRepository->shouldReceive('create')+ ->once()+ ->withArgs(fn (array $attributes): bool => $attributes['event_occurrence_id'] === $occurrenceId+ && $attributes['products_sold'] === 3+ && $attributes['attendees_registered'] === 2+ && $attributes['sales_total_gross'] === 132.00+ && $attributes['sales_total_before_additions'] === 120.00+ && $attributes['total_tax'] === 9.50+ && $attributes['total_fee'] === 2.50+ && $attributes['orders_created'] === 1);++ $this->eventOccurrenceDailyStatisticRepository->shouldReceive('findFirstWhere')+ ->with(['event_occurrence_id' => $occurrenceId, 'date' => '2024-01-15'])+ ->andReturnNull();+ $occurrenceDailyCreate = null;+ $this->eventOccurrenceDailyStatisticRepository->shouldReceive('create')+ ->once()+ ->andReturnUsing(function (array $attributes) use (&$occurrenceDailyCreate) {+ $occurrenceDailyCreate = $attributes;++ return Mockery::mock(EventOccurrenceDailyStatisticDomainObject::class);+ });++ $this->promoCodeRepository->shouldNotReceive('incrementEach');++ $this->productRepository->shouldReceive('increment')+ ->once()->with(1, ProductDomainObjectAbstract::SALES_VOLUME, 100.00);+ $this->productRepository->shouldReceive('increment')+ ->once()->with(2, ProductDomainObjectAbstract::SALES_VOLUME, 20.00);++ $this->service->incrementForOrder($order);++ $this->assertSame($occurrenceId, $occurrenceDailyCreate['event_occurrence_id']);+ $this->assertSame('2024-01-15', $occurrenceDailyCreate['date']);+ $this->assertSame(3, $occurrenceDailyCreate['products_sold']);+ $this->assertSame(2, $occurrenceDailyCreate['attendees_registered']);+ $this->assertSame(132.00, $occurrenceDailyCreate['sales_total_gross']);+ $this->assertSame(1, $occurrenceDailyCreate['orders_created']);+ }}diff --git a/backend/tests/Unit/Services/Domain/Order/MarkOrderAsPaidServiceTest.php b/backend/tests/Unit/Services/Domain/Order/MarkOrderAsPaidServiceTest.phpnew file mode 100644index 000000000..ad3988496--- /dev/null+++ b/backend/tests/Unit/Services/Domain/Order/MarkOrderAsPaidServiceTest.php@@ -0,0 +1,276 @@+<?php++namespace Tests\Unit\Services\Domain\Order;++use HiEvents\DomainObjects\EventDomainObject;+use HiEvents\DomainObjects\EventSettingDomainObject;+use HiEvents\DomainObjects\Generated\OrderDomainObjectAbstract;+use HiEvents\DomainObjects\InvoiceDomainObject;+use HiEvents\DomainObjects\OrderDomainObject;+use HiEvents\DomainObjects\OrganizerDomainObject;+use HiEvents\DomainObjects\Status\AttendeeStatus;+use HiEvents\DomainObjects\Status\InvoiceStatus;+use HiEvents\DomainObjects\Status\OrderPaymentStatus;+use HiEvents\DomainObjects\Status\OrderStatus;+use HiEvents\Events\OrderStatusChangedEvent;+use HiEvents\Exceptions\ResourceConflictException;+use HiEvents\Repository\Interfaces\AffiliateRepositoryInterface;+use HiEvents\Repository\Interfaces\AttendeeRepositoryInterface;+use HiEvents\Repository\Interfaces\EventRepositoryInterface;+use HiEvents\Repository\Interfaces\InvoiceRepositoryInterface;+use HiEvents\Repository\Interfaces\OrderRepositoryInterface;+use HiEvents\Services\Domain\Mail\SendOrderDetailsService;+use HiEvents\Services\Domain\Order\MarkOrderAsPaidService;+use HiEvents\Services\Domain\Order\OccurrenceStatusValidator;+use HiEvents\Services\Domain\Order\OrderApplicationFeeCalculationService;+use HiEvents\Services\Domain\Order\OrderApplicationFeeService;+use HiEvents\Services\Infrastructure\DomainEvents\DomainEventDispatcherService;+use HiEvents\Services\Infrastructure\DomainEvents\Enums\DomainEventType;+use HiEvents\Services\Infrastructure\DomainEvents\Events\OrderEvent;+use Illuminate\Database\DatabaseManager;+use Illuminate\Support\Facades\Event;+use Mockery;+use Mockery\MockInterface;+use Tests\TestCase;++class MarkOrderAsPaidServiceTest extends TestCase+{+ private const ORDER_ID = 100;++ private const EVENT_ID = 200;++ private const AFFILIATE_ID = 300;++ private OrderRepositoryInterface|MockInterface $orderRepository;++ private AffiliateRepositoryInterface|MockInterface $affiliateRepository;++ private InvoiceRepositoryInterface|MockInterface $invoiceRepository;++ private AttendeeRepositoryInterface|MockInterface $attendeeRepository;++ private DomainEventDispatcherService|MockInterface $domainEventDispatcherService;++ private EventRepositoryInterface|MockInterface $eventRepository;++ private OrderApplicationFeeService|MockInterface $orderApplicationFeeService;++ private SendOrderDetailsService|MockInterface $sendOrderDetailsService;++ private OccurrenceStatusValidator|MockInterface $occurrenceStatusValidator;++ private MarkOrderAsPaidService $service;++ protected function setUp(): void+ {+ parent::setUp();+ Event::fake();++ $this->orderRepository = Mockery::mock(OrderRepositoryInterface::class);+ $this->affiliateRepository = Mockery::mock(AffiliateRepositoryInterface::class);+ $this->invoiceRepository = Mockery::mock(InvoiceRepositoryInterface::class);+ $this->attendeeRepository = Mockery::mock(AttendeeRepositoryInterface::class);+ $this->domainEventDispatcherService = Mockery::mock(DomainEventDispatcherService::class);+ $this->eventRepository = Mockery::mock(EventRepositoryInterface::class);+ $this->orderApplicationFeeService = Mockery::mock(OrderApplicationFeeService::class);+ $this->sendOrderDetailsService = Mockery::mock(SendOrderDetailsService::class);+ $this->occurrenceStatusValidator = Mockery::mock(OccurrenceStatusValidator::class);++ $databaseManager = Mockery::mock(DatabaseManager::class);+ $databaseManager->shouldReceive('transaction')->andReturnUsing(fn (callable $callback) => $callback());++ $this->orderRepository->shouldReceive('loadRelation')->andReturnSelf();+ $this->eventRepository->shouldReceive('loadRelation')->andReturnSelf();++ $this->service = new MarkOrderAsPaidService(+ $this->orderRepository,+ $databaseManager,+ $this->affiliateRepository,+ $this->invoiceRepository,+ $this->attendeeRepository,+ $this->domainEventDispatcherService,+ Mockery::mock(OrderApplicationFeeCalculationService::class),+ $this->eventRepository,+ $this->orderApplicationFeeService,+ $this->sendOrderDetailsService,+ $this->occurrenceStatusValidator,+ );+ }++ public function test_marking_an_awaiting_offline_order_as_paid_completes_it_and_fires_the_completion_event(): void+ {+ $this->givenOrderAwaitingOfflinePayment();+ $this->givenEventWithoutOrganizerConfiguration();+ $this->invoiceRepository->shouldReceive('findLatestInvoiceForOrder')->once()->with(self::ORDER_ID)->andReturnNull();++ $this->orderRepository->shouldReceive('updateFromArray')+ ->once()+ ->with(self::ORDER_ID, [+ OrderDomainObjectAbstract::STATUS => OrderStatus::COMPLETED->name,+ OrderDomainObjectAbstract::PAYMENT_STATUS => OrderPaymentStatus::PAYMENT_RECEIVED->name,+ ]);++ $this->attendeeRepository->shouldReceive('updateWhere')+ ->once()+ ->with(+ ['status' => AttendeeStatus::ACTIVE->name],+ ['order_id' => self::ORDER_ID, 'status' => AttendeeStatus::AWAITING_PAYMENT->name],+ );++ $this->affiliateRepository->shouldNotReceive('incrementSales');++ $this->domainEventDispatcherService->shouldReceive('dispatch')+ ->once()+ ->with(Mockery::on(+ fn (OrderEvent $event) => $event->type === DomainEventType::ORDER_MARKED_AS_PAID+ && $event->orderId === self::ORDER_ID+ ));++ $this->sendOrderDetailsService->shouldReceive('sendCustomerOrderSummary')->once();++ $result = $this->service->markOrderAsPaid(self::ORDER_ID, self::EVENT_ID);++ $this->assertSame(OrderStatus::COMPLETED->name, $result->getStatus());++ Event::assertDispatched(+ OrderStatusChangedEvent::class,+ fn (OrderStatusChangedEvent $event) => $event->order->getId() === self::ORDER_ID+ && $event->order->isOrderCompleted()+ && $event->sendEmails === false+ );+ }++ public function test_affiliate_sales_are_credited_with_the_order_gross_when_marked_as_paid(): void+ {+ $this->givenOrderAwaitingOfflinePayment(affiliateId: self::AFFILIATE_ID, totalGross: 125.5);+ $this->givenEventWithoutOrganizerConfiguration();+ $this->invoiceRepository->shouldReceive('findLatestInvoiceForOrder')->andReturnNull();+ $this->orderRepository->shouldReceive('updateFromArray')->once();+ $this->attendeeRepository->shouldReceive('updateWhere')->once();+ $this->domainEventDispatcherService->shouldReceive('dispatch')->once();+ $this->sendOrderDetailsService->shouldReceive('sendCustomerOrderSummary')->once();++ $this->affiliateRepository->shouldReceive('incrementSales')+ ->once()+ ->with(self::AFFILIATE_ID, 125.5);++ $this->service->markOrderAsPaid(self::ORDER_ID, self::EVENT_ID);+ }++ public function test_the_latest_invoice_is_marked_paid(): void+ {+ $this->givenOrderAwaitingOfflinePayment();+ $this->givenEventWithoutOrganizerConfiguration();+ $this->orderRepository->shouldReceive('updateFromArray')->once();+ $this->attendeeRepository->shouldReceive('updateWhere')->once();+ $this->domainEventDispatcherService->shouldReceive('dispatch')->once();+ $this->sendOrderDetailsService->shouldReceive('sendCustomerOrderSummary')->once();++ $this->invoiceRepository->shouldReceive('findLatestInvoiceForOrder')+ ->once()+ ->with(self::ORDER_ID)+ ->andReturn((new InvoiceDomainObject)->setId(77));+ $this->invoiceRepository->shouldReceive('updateFromArray')+ ->once()+ ->with(77, ['status' => InvoiceStatus::PAID->name]);++ $this->service->markOrderAsPaid(self::ORDER_ID, self::EVENT_ID);+ }++ public function test_an_order_that_is_not_awaiting_offline_payment_cannot_be_marked_as_paid(): void+ {+ $this->givenOrderAwaitingOfflinePayment(status: OrderStatus::COMPLETED);+ $this->givenEventWithoutOrganizerConfiguration(expectSecondLoad: false);++ $this->orderRepository->shouldNotReceive('updateFromArray');+ $this->attendeeRepository->shouldNotReceive('updateWhere');+ $this->occurrenceStatusValidator->shouldNotReceive('assertOrderOccurrencesArePurchasable');++ $this->expectException(ResourceConflictException::class);++ try {+ $this->service->markOrderAsPaid(self::ORDER_ID, self::EVENT_ID);+ } finally {+ Event::assertNotDispatched(OrderStatusChangedEvent::class);+ }+ }++ public function test_an_order_for_a_cancelled_occurrence_cannot_be_marked_as_paid(): void+ {+ $this->givenOrderAwaitingOfflinePayment(occurrencePurchasable: false);+ $this->givenEventWithoutOrganizerConfiguration(expectSecondLoad: false);++ $this->orderRepository->shouldNotReceive('updateFromArray');+ $this->attendeeRepository->shouldNotReceive('updateWhere');++ $this->expectException(ResourceConflictException::class);++ try {+ $this->service->markOrderAsPaid(self::ORDER_ID, self::EVENT_ID);+ } finally {+ Event::assertNotDispatched(OrderStatusChangedEvent::class);+ }+ }++ private function givenOrderAwaitingOfflinePayment(+ OrderStatus $status = OrderStatus::AWAITING_OFFLINE_PAYMENT,+ ?int $affiliateId = null,+ float $totalGross = 50.0,+ bool $occurrencePurchasable = true,+ ): void {+ $pending = (new OrderDomainObject)+ ->setId(self::ORDER_ID)+ ->setEventId(self::EVENT_ID)+ ->setStatus($status->name)+ ->setTotalGross($totalGross)+ ->setCurrency('USD');++ $this->orderRepository->shouldReceive('findFirstWhere')+ ->once()+ ->with([+ OrderDomainObjectAbstract::ID => self::ORDER_ID,+ OrderDomainObjectAbstract::EVENT_ID => self::EVENT_ID,+ ])+ ->andReturn($pending);++ if ($status !== OrderStatus::AWAITING_OFFLINE_PAYMENT) {+ return;+ }++ if (! $occurrencePurchasable) {+ $this->occurrenceStatusValidator->shouldReceive('assertOrderOccurrencesArePurchasable')+ ->once()+ ->andThrow(new ResourceConflictException('occurrence cancelled'));++ return;+ }++ $this->occurrenceStatusValidator->shouldReceive('assertOrderOccurrencesArePurchasable')->once();++ $completed = (new OrderDomainObject)+ ->setId(self::ORDER_ID)+ ->setEventId(self::EVENT_ID)+ ->setStatus(OrderStatus::COMPLETED->name)+ ->setTotalGross($totalGross)+ ->setCurrency('USD')+ ->setAffiliateId($affiliateId);++ $this->orderRepository->shouldReceive('findById')+ ->once()+ ->with(self::ORDER_ID)+ ->andReturn($completed);+ }++ private function givenEventWithoutOrganizerConfiguration(bool $expectSecondLoad = true): void+ {+ $event = (new EventDomainObject)+ ->setId(self::EVENT_ID)+ ->setOrganizer(new OrganizerDomainObject)+ ->setEventSettings(new EventSettingDomainObject);++ $this->eventRepository->shouldReceive('findById')+ ->times($expectSecondLoad ? 2 : 1)+ ->with(self::EVENT_ID)+ ->andReturn($event);+ }+}diff --git a/backend/tests/Unit/Services/Domain/Payment/Stripe/EventHandlers/ChargeRefundUpdatedHandlerTest.php b/backend/tests/Unit/Services/Domain/Payment/Stripe/EventHandlers/ChargeRefundUpdatedHandlerTest.phpnew file mode 100644index 000000000..de6ff4e3e--- /dev/null+++ b/backend/tests/Unit/Services/Domain/Payment/Stripe/EventHandlers/ChargeRefundUpdatedHandlerTest.php@@ -0,0 +1,221 @@+<?php++namespace Tests\Unit\Services\Domain\Payment\Stripe\EventHandlers;++use HiEvents\DomainObjects\Enums\PaymentProviders;+use HiEvents\DomainObjects\Generated\OrderDomainObjectAbstract;+use HiEvents\DomainObjects\OrderDomainObject;+use HiEvents\DomainObjects\OrderRefundDomainObject;+use HiEvents\DomainObjects\Status\OrderRefundStatus;+use HiEvents\DomainObjects\StripePaymentDomainObject;+use HiEvents\Repository\Interfaces\OrderRefundRepositoryInterface;+use HiEvents\Repository\Interfaces\OrderRepositoryInterface;+use HiEvents\Repository\Interfaces\StripePaymentsRepositoryInterface;+use HiEvents\Services\Domain\EventStatistics\EventStatisticsRefundService;+use HiEvents\Services\Domain\Payment\Stripe\EventHandlers\ChargeRefundUpdatedHandler;+use HiEvents\Services\Infrastructure\DomainEvents\DomainEventDispatcherService;+use HiEvents\Services\Infrastructure\DomainEvents\Enums\DomainEventType;+use HiEvents\Services\Infrastructure\DomainEvents\Events\OrderEvent;+use HiEvents\Values\MoneyValue;+use Illuminate\Database\DatabaseManager;+use Illuminate\Log\Logger;+use Mockery;+use Mockery\MockInterface;+use Stripe\Refund;+use Tests\TestCase;++class ChargeRefundUpdatedHandlerTest extends TestCase+{+ private const ORDER_ID = 500;++ private const PAYMENT_INTENT_ID = 'pi_test_123';++ private const REFUND_ID = 're_test_456';++ private OrderRepositoryInterface|MockInterface $orderRepository;++ private StripePaymentsRepositoryInterface|MockInterface $stripePaymentsRepository;++ private EventStatisticsRefundService|MockInterface $eventStatisticsRefundService;++ private OrderRefundRepositoryInterface|MockInterface $orderRefundRepository;++ private DomainEventDispatcherService|MockInterface $domainEventDispatcherService;++ private ChargeRefundUpdatedHandler $handler;++ protected function setUp(): void+ {+ parent::setUp();++ $this->orderRepository = Mockery::mock(OrderRepositoryInterface::class);+ $this->stripePaymentsRepository = Mockery::mock(StripePaymentsRepositoryInterface::class);+ $this->eventStatisticsRefundService = Mockery::mock(EventStatisticsRefundService::class);+ $this->orderRefundRepository = Mockery::mock(OrderRefundRepositoryInterface::class);+ $this->domainEventDispatcherService = Mockery::mock(DomainEventDispatcherService::class);++ $databaseManager = Mockery::mock(DatabaseManager::class);+ $databaseManager->shouldReceive('transaction')->andReturnUsing(fn (callable $callback) => $callback());++ $this->handler = new ChargeRefundUpdatedHandler(+ $this->orderRepository,+ $this->stripePaymentsRepository,+ Mockery::mock(Logger::class)->shouldIgnoreMissing(),+ $databaseManager,+ $this->eventStatisticsRefundService,+ $this->orderRefundRepository,+ $this->domainEventDispatcherService,+ );+ }++ public function test_a_partial_refund_records_the_amount_adjusts_statistics_and_marks_the_order_partially_refunded(): void+ {+ $this->givenStripePaymentForOrder();+ $this->givenNoExistingRefund();+ $this->givenOrder(totalGross: 100.0, totalRefunded: 0.0);++ $this->orderRepository->shouldReceive('increment')+ ->once()+ ->with(self::ORDER_ID, OrderDomainObjectAbstract::TOTAL_REFUNDED, 25.0);+ $this->orderRepository->shouldReceive('updateFromArray')+ ->once()+ ->with(self::ORDER_ID, [OrderDomainObjectAbstract::REFUND_STATUS => OrderRefundStatus::PARTIALLY_REFUNDED->name]);++ $this->eventStatisticsRefundService->shouldReceive('updateForRefund')+ ->once()+ ->withArgs(fn (OrderDomainObject $order, MoneyValue $amount): bool => $order->getId() === self::ORDER_ID+ && $amount->toMinorUnit() === 2500);++ $createdRefund = null;+ $this->orderRefundRepository->shouldReceive('create')+ ->once()+ ->andReturnUsing(function (array $attributes) use (&$createdRefund) {+ $createdRefund = $attributes;++ return new OrderRefundDomainObject;+ });++ $this->domainEventDispatcherService->shouldReceive('dispatch')+ ->once()+ ->with(Mockery::on(fn (OrderEvent $event) => $event->type === DomainEventType::ORDER_REFUNDED+ && $event->orderId === self::ORDER_ID));++ $this->handler->handleEvent($this->refund(amountMinor: 2500, status: 'succeeded'));++ $this->assertSame(self::ORDER_ID, $createdRefund['order_id']);+ $this->assertSame(PaymentProviders::STRIPE->value, $createdRefund['payment_provider']);+ $this->assertSame(self::REFUND_ID, $createdRefund['refund_id']);+ $this->assertSame(25.0, $createdRefund['amount']);+ $this->assertSame('USD', $createdRefund['currency']);+ $this->assertSame('succeeded', $createdRefund['status']);+ $this->assertSame(self::PAYMENT_INTENT_ID, $createdRefund['metadata']['payment_intent']);+ }++ public function test_a_refund_that_reaches_the_order_total_marks_the_order_fully_refunded(): void+ {+ $this->givenStripePaymentForOrder();+ $this->givenNoExistingRefund();+ $this->givenOrder(totalGross: 100.0, totalRefunded: 60.0);++ $this->orderRepository->shouldReceive('increment')->once()->with(self::ORDER_ID, OrderDomainObjectAbstract::TOTAL_REFUNDED, 40.0);+ $this->orderRepository->shouldReceive('updateFromArray')+ ->once()+ ->with(self::ORDER_ID, [OrderDomainObjectAbstract::REFUND_STATUS => OrderRefundStatus::REFUNDED->name]);+ $this->eventStatisticsRefundService->shouldReceive('updateForRefund')->once();+ $this->orderRefundRepository->shouldReceive('create')->once()->andReturn(new OrderRefundDomainObject);+ $this->domainEventDispatcherService->shouldReceive('dispatch')->once();++ $this->handler->handleEvent($this->refund(amountMinor: 4000, status: 'succeeded'));+ }++ public function test_a_replayed_refund_webhook_is_ignored(): void+ {+ $this->givenStripePaymentForOrder();+ $this->orderRefundRepository->shouldReceive('findFirstWhere')+ ->once()+ ->with(['refund_id' => self::REFUND_ID])+ ->andReturn((new OrderRefundDomainObject)->setId(1)->setRefundId(self::REFUND_ID));++ $this->orderRepository->shouldNotReceive('findById');+ $this->orderRepository->shouldNotReceive('increment');+ $this->orderRepository->shouldNotReceive('updateFromArray');+ $this->eventStatisticsRefundService->shouldNotReceive('updateForRefund');+ $this->orderRefundRepository->shouldNotReceive('create');+ $this->domainEventDispatcherService->shouldNotReceive('dispatch');++ $this->handler->handleEvent($this->refund(amountMinor: 2500, status: 'succeeded'));+ }++ public function test_a_refund_for_an_unknown_payment_intent_is_ignored(): void+ {+ $this->stripePaymentsRepository->shouldReceive('findFirstWhere')+ ->once()+ ->with(['payment_intent_id' => self::PAYMENT_INTENT_ID])+ ->andReturnNull();++ $this->orderRefundRepository->shouldNotReceive('findFirstWhere');+ $this->orderRepository->shouldNotReceive('findById');+ $this->eventStatisticsRefundService->shouldNotReceive('updateForRefund');++ $this->handler->handleEvent($this->refund(amountMinor: 2500, status: 'succeeded'));+ }++ public function test_a_failed_refund_marks_the_order_refund_failed_without_touching_statistics(): void+ {+ $this->givenStripePaymentForOrder();+ $this->givenNoExistingRefund();+ $this->givenOrder(totalGross: 100.0, totalRefunded: 0.0);++ $this->orderRepository->shouldReceive('updateFromArray')+ ->once()+ ->with(self::ORDER_ID, [OrderDomainObjectAbstract::REFUND_STATUS => OrderRefundStatus::REFUND_FAILED->name]);++ $this->orderRepository->shouldNotReceive('increment');+ $this->eventStatisticsRefundService->shouldNotReceive('updateForRefund');+ $this->orderRefundRepository->shouldNotReceive('create');+ $this->domainEventDispatcherService->shouldNotReceive('dispatch');++ $this->handler->handleEvent($this->refund(amountMinor: 2500, status: 'failed'));+ }++ private function refund(int $amountMinor, string $status): Refund+ {+ return Refund::constructFrom([+ 'id' => self::REFUND_ID,+ 'object' => 'refund',+ 'amount' => $amountMinor,+ 'currency' => 'usd',+ 'payment_intent' => self::PAYMENT_INTENT_ID,+ 'status' => $status,+ 'metadata' => [],+ ]);+ }++ private function givenStripePaymentForOrder(): void+ {+ $this->stripePaymentsRepository->shouldReceive('findFirstWhere')+ ->once()+ ->with(['payment_intent_id' => self::PAYMENT_INTENT_ID])+ ->andReturn((new StripePaymentDomainObject)->setOrderId(self::ORDER_ID));+ }++ private function givenNoExistingRefund(): void+ {+ $this->orderRefundRepository->shouldReceive('findFirstWhere')+ ->once()+ ->with(['refund_id' => self::REFUND_ID])+ ->andReturnNull();+ }++ private function givenOrder(float $totalGross, float $totalRefunded): void+ {+ $this->orderRepository->shouldReceive('findById')+ ->once()+ ->with(self::ORDER_ID)+ ->andReturn((new OrderDomainObject)+ ->setId(self::ORDER_ID)+ ->setCurrency('USD')+ ->setTotalGross($totalGross)+ ->setTotalRefunded($totalRefunded));+ }+}diff --git a/e2e/api/api-client.ts b/e2e/api/api-client.tsindex 6928c5ce7..84bf64250 100644--- a/e2e/api/api-client.ts+++ b/e2e/api/api-client.ts@@ -253,6 +253,25 @@ export class ApiClient {return check(this.request.post(`events/${eventId}/orders/${orderId}/cancel`, { headers: jsonHeaders }));}+ listAttendees(eventId: number): Promise<AttendeeRecord[]> {+ return unwrap<AttendeeRecord[]>(this.request.get(`events/${eventId}/attendees`, { headers: jsonHeaders }));+ }++ async findAttendeeIdByPublicId(eventId: number, publicId: string): Promise<number> {+ const attendees = await this.listAttendees(eventId);+ const attendee = attendees.find((candidate) => candidate.public_id === publicId);+ if (!attendee) {+ throw new Error(`Attendee ${publicId} not found among ${attendees.length} attendees for event ${eventId}`);+ }+ return attendee.id;+ }++ updateAttendeeStatus(eventId: number, attendeeId: number, status: 'ACTIVE' | 'CANCELLED'): Promise<void> {+ return check(+ this.request.patch(`events/${eventId}/attendees/${attendeeId}`, { headers: jsonHeaders, data: { status } }),+ );+ }+async generateOccurrences(eventId: number, recurrenceRule: RecurrenceRule): Promise<void> {const response = await this.request.post(`events/${eventId}/occurrences/generate`, {headers: jsonHeaders,diff --git a/e2e/api/types.ts b/e2e/api/types.tsindex 125c87485..8a006ce56 100644--- a/e2e/api/types.ts+++ b/e2e/api/types.ts@@ -53,6 +53,7 @@ export interface ProductPrice {id: number;price: number;label?: string | null;+ quantity_sold?: number;}export interface ProductRecord {diff --git a/e2e/pages/event-dashboard.page.ts b/e2e/pages/event-dashboard.page.tsnew file mode 100644index 000000000..3de4748fe--- /dev/null+++ b/e2e/pages/event-dashboard.page.ts@@ -0,0 +1,21 @@+import type { Locator, Page } from '@playwright/test';++export type EventStatKey = 'attendees' | 'products_sold' | 'refunded' | 'gross_sales' | 'page_views' | 'orders';++export class EventDashboardPage {+ constructor(private readonly page: Page) {}++ async goto(eventId: number): Promise<void> {+ await this.page.goto(`/manage/event/${eventId}/dashboard`);+ await this.page.waitForLoadState('networkidle');+ }++ async gotoOccurrence(eventId: number, occurrenceId: number): Promise<void> {+ await this.page.goto(`/manage/event/${eventId}/occurrences/${occurrenceId}`);+ await this.page.waitForLoadState('networkidle');+ }++ stat(key: EventStatKey): Locator {+ return this.page.getByTestId(`event-stat-${key}-value`);+ }+}diff --git a/e2e/tests/management/event-dashboard-stats.spec.ts b/e2e/tests/management/event-dashboard-stats.spec.tsnew file mode 100644index 000000000..e810b0c9c--- /dev/null+++ b/e2e/tests/management/event-dashboard-stats.spec.ts@@ -0,0 +1,120 @@+import { test, expect } from '../../fixtures';+import {+ createCompletedOrder,+ createCompletedPaidOrder,+ createLiveEventWithProduct,+ createRecurringLiveEvent,+} from '../../api/factory';+import { EventDashboardPage, type EventStatKey } from '../../pages/event-dashboard.page';+import { uniqueEmail } from '../../utils/unique';++type Ledger = Partial<Record<EventStatKey, string>>;++const formatUsd = (amount: number): string => `$${amount.toFixed(2)}`;++async function expectLedger(+ dashboard: EventDashboardPage,+ eventId: number,+ expected: Ledger,+ occurrenceId?: number,+): Promise<void> {+ await expect(async () => {+ if (occurrenceId) {+ await dashboard.gotoOccurrence(eventId, occurrenceId);+ } else {+ await dashboard.goto(eventId);+ }+ for (const [key, value] of Object.entries(expected) as [EventStatKey, string][]) {+ await expect(dashboard.stat(key)).toHaveText(value, { timeout: 5_000 });+ }+ }).toPass({ timeout: 60_000, intervals: [2_000, 3_000, 5_000] });+}++test.describe('event dashboard stats ledger', () => {+ test('every order path adds up on the dashboard: paid, manual attendee, order cancel, attendee cancel and reactivate', async ({+ authedPage,+ api,+ account,+ publicApi,+ }) => {+ const event = await createLiveEventWithProduct(api, { organizerId: account.organizerId, price: 25 });+ const dashboard = new EventDashboardPage(authedPage);++ const orderA = await createCompletedPaidOrder(api, publicApi, event, { quantity: 2 });+ const orderB = await createCompletedPaidOrder(api, publicApi, event, { quantity: 1 });+ const manualAmountPaid = 10;+ await api.createAttendee(event.eventId, {+ product_id: event.productId,+ product_price_id: event.priceId,+ email: uniqueEmail('manual'),+ first_name: 'Manual',+ last_name: 'Attendee',+ amount_paid: manualAmountPaid,+ send_confirmation_email: false,+ locale: 'en',+ });+ const grossSales = formatUsd(orderA.totalGross + orderB.totalGross + manualAmountPaid);++ await expectLedger(dashboard, event.eventId, {+ attendees: '4',+ products_sold: '4',+ gross_sales: grossSales,+ orders: '3',+ });++ await api.cancelOrder(event.eventId, orderB.orderId);++ await expectLedger(dashboard, event.eventId, {+ attendees: '3',+ products_sold: '3',+ gross_sales: grossSales,+ orders: '2',+ });++ const attendeeId = await api.findAttendeeIdByPublicId(event.eventId, orderA.attendees[0].publicId);+ await api.updateAttendeeStatus(event.eventId, attendeeId, 'CANCELLED');++ await expectLedger(dashboard, event.eventId, {+ attendees: '2',+ products_sold: '3',+ orders: '2',+ });++ await api.updateAttendeeStatus(event.eventId, attendeeId, 'ACTIVE');++ await expectLedger(dashboard, event.eventId, {+ attendees: '3',+ products_sold: '3',+ gross_sales: grossSales,+ orders: '2',+ });++ const product = await api.getProduct(event.eventId, event.productId);+ expect(product.prices?.[0]?.quantity_sold).toBe(3);+ });++ test('a recurring event keeps per-occurrence stats separate and the event total is their sum', async ({+ authedPage,+ api,+ account,+ publicApi,+ }) => {+ const event = await createRecurringLiveEvent(api, account.organizerId, { count: 2, price: 0 });+ const [first, second] = event.occurrences;+ const dashboard = new EventDashboardPage(authedPage);++ await createCompletedOrder(publicApi, event, { quantity: 2, eventOccurrenceId: first.id });+ const secondOrder = await createCompletedOrder(publicApi, event, { quantity: 1, eventOccurrenceId: second.id });++ await expectLedger(dashboard, event.eventId, { attendees: '3', products_sold: '3', orders: '2' });+ await expectLedger(dashboard, event.eventId, { attendees: '2', products_sold: '2', orders: '1' }, first.id);+ await expectLedger(dashboard, event.eventId, { attendees: '1', products_sold: '1', orders: '1' }, second.id);++ const secondOrderId = await api.findOrderIdByShortId(event.eventId, secondOrder.orderShortId);+ await api.cancelOrder(event.eventId, secondOrderId);++ await expectLedger(dashboard, event.eventId, { attendees: '2', products_sold: '2', orders: '1' });+ await expectLedger(dashboard, event.eventId, { attendees: '2', products_sold: '2', orders: '1' }, first.id);+ await expectLedger(dashboard, event.eventId, { attendees: '0', products_sold: '0', orders: '0' }, second.id);+ });+});diff --git a/frontend/src/components/common/KpiGrid/index.tsx b/frontend/src/components/common/KpiGrid/index.tsxindex ca0ee92db..e435861c5 100644--- a/frontend/src/components/common/KpiGrid/index.tsx+++ b/frontend/src/components/common/KpiGrid/index.tsx@@ -29,6 +29,7 @@ interface KpiCellProps {sparkline?: number[];delta?: KpiCellDelta | null;isLoading?: boolean;+ testId?: string;}const formatPercent = (percent: number, sign: '+' | '-') => {@@ -36,10 +37,10 @@ const formatPercent = (percent: number, sign: '+' | '-') => {return `${sign}${abs}%`;};-export const KpiCell = ({label, value, sparkline, delta, isLoading = false}: KpiCellProps) => {+export const KpiCell = ({label, value, sparkline, delta, isLoading = false, testId}: KpiCellProps) => {if (isLoading) {return (- <div className={classes.cell}>+ <div className={classes.cell} data-testid={testId}><div className={classes.label}>{label}</div><div className={classes.skeletonRow}><Skeleton height={20} width={80} radius="sm"/>@@ -72,10 +73,10 @@ export const KpiCell = ({label, value, sparkline, delta, isLoading = false}: Kpi}return (- <div className={classes.cell}>+ <div className={classes.cell} data-testid={testId}><div className={classes.label}>{label}</div><div className={classes.middleRow}>- <div className={classes.value}>{value}</div>+ <div className={classes.value} data-testid={testId ? `${testId}-value` : undefined}>{value}</div>{sparkline && sparkline.length > 0 ? (<SparklineclassName={classes.sparkline}diff --git a/frontend/src/components/common/StatBoxes/index.tsx b/frontend/src/components/common/StatBoxes/index.tsxindex 3770ccbe4..1c2c4bc43 100644--- a/frontend/src/components/common/StatBoxes/index.tsx+++ b/frontend/src/components/common/StatBoxes/index.tsx@@ -119,6 +119,7 @@ export const StatBoxes = ({occurrenceId, dateRange, event}: StatBoxesProps = {}){visibleCells.map((cell) => (<KpiCellkey={cell.key}+ testId={`event-stat-${cell.key}`}label={cell.label}value={cell.value}sparkline={cell.sparkline}