[Feature] add integration test reproducing the race in competition

.github/workflows/main.yml

@@ -24,6 +24,7 @@ jobs:
         with:
           java-version: 25
           distribution: temurin
+          cache: maven
 
       - name: Verify project
         run: mvn clean verify
@@ -39,14 +40,13 @@ jobs:
           #        -Dsonar.organization=ita-social-projects \
           #        -Dsonar.host.url=https://sonarcloud.io \
 
-          #- name: Test Reporter
-          # #v1.5.0
-          #uses: dorny/test-reporter@0d00bb14cb0cc2c9b8985df6e81dd333188224e1
-          #if: success() || failure()
-          #with:
-          # name: Tests Report
-          #path: '**/target/surefire-reports/*.xml'
-          #reporter: java-junit
+      - name: Test Reporter
+        uses: dorny/test-reporter@v1.9.1
+        if: success() || failure()
+        with:
+          name: Tests Report
+          path: '**/target/surefire-reports/TEST-*.xml,**/target/failsafe-reports/TEST-*.xml'
+          reporter: java-junit
 
   build-and-push-backend-image:
     needs: build

pom.xml

@@ -40,6 +40,7 @@
         <azure-core-http-netty-version>1.15.12</azure-core-http-netty-version>
         <spring-modulith-events-api-version>2.0.1</spring-modulith-events-api-version>
         <poi-version>5.5.1</poi-version>
+        <testcontainers-postgres-version>1.20.3</testcontainers-postgres-version>
     </properties>
     <dependencies>
         <dependency>
@@ -182,6 +183,18 @@
             <groupId>org.springframework.boot</groupId>
             <artifactId>spring-boot-starter-security-oauth2-client</artifactId>
         </dependency>
+        <!--  take out version into variable  -->
+        <dependency>
+            <groupId>org.testcontainers</groupId>
+            <artifactId>postgresql</artifactId>
+            <version>${testcontainers-postgres-version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-testcontainers</artifactId>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
     <dependencyManagement>
         <dependencies>
@@ -226,6 +239,25 @@
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-surefire-plugin</artifactId>
                 <version>3.5.4</version>
+                <configuration>
+                    <excludedGroups>integration</excludedGroups>
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-failsafe-plugin</artifactId>
+                <version>3.5.4</version>
+                <configuration>
+                    <groups>integration</groups>
+                </configuration>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>integration-test</goal>
+                            <goal>verify</goal>
+                        </goals>
+                    </execution>
+                </executions>
             </plugin>
             <plugin>
                 <groupId>net.revelc.code.formatter</groupId>

src/main/java/com/itasocialacademy/oitassist/competition/dao/repository/TourRepository.java

@@ -25,4 +25,6 @@ public interface TourRepository extends JpaRepository<Tour, Long> {
     Optional<Tour> findByStageIdAndSortPosition(Long stageId, Short sortPosition);
 
     Optional<Tour> findFirstByStageIdAndSortPositionLessThanOrderBySortPositionDesc(Long stageId, Short sortPosition);
+
+    long countByStageId(Long stageId);
 }

src/main/java/com/itasocialacademy/oitassist/competition/service/TourServiceImpl.java

@@ -183,6 +183,7 @@ public void delete(Long pathStageId, Long tourId) {
 
         validator.validateTourEligibility(pathStageId, tour.getStageId());
         validator.validateImmutabilityByStageId(tour.getStageId());
+        validator.validateTourDeletionKeepsStageNonEmpty(tour.getStageId());
 
         tourRepository.delete(tour);
     }

src/main/java/com/itasocialacademy/oitassist/competition/validation/HierarchyValidator.java

@@ -15,11 +15,15 @@
 import com.itasocialacademy.oitassist.competition.exceptions.StaleEntityVersionException;
 import com.itasocialacademy.oitassist.competition.spi.ParticipationInquiryPort;
 import com.itasocialacademy.oitassist.security.api.interfaces.SecurityFacade;
+import jakarta.annotation.PostConstruct;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.PersistenceContext;
 import java.time.ZonedDateTime;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
 import lombok.RequiredArgsConstructor;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.security.access.AccessDeniedException;
 import org.springframework.stereotype.Component;
 import org.springframework.transaction.annotation.Transactional;
@@ -33,6 +37,22 @@ public class HierarchyValidator {
     private final SecurityFacade securityFacade;
     private final ParticipationInquiryPort participationInquiryPort;
 
+    @PersistenceContext
+    private final EntityManager entityManager;
+
+    @Value("${competition.hierarchy-lock-timeout-ms:3000}")
+    private int hierarchyLockTimeoutMs;
+
+    @PostConstruct
+    void validateLockTimeoutConfig() {
+        if (hierarchyLockTimeoutMs <= 0) {
+            throw new IllegalStateException(
+                "competition.hierarchy-lock-timeout-ms must be positive "
+                    + "(0 disables the Postgres lock timeout entirely, causing indefinite waits); got "
+                    + hierarchyLockTimeoutMs);
+        }
+    }
+
     @Transactional(readOnly = true)
     public void checkVisibilityAccess(Long competitionId) {
         Competition competition = competitionRepository.findById(competitionId)
@@ -371,7 +391,30 @@ public void validateEntityVersion(Long expectedVersion, Long actualVersion, Clas
      */
     @Transactional
     public Competition lockCompetitionForUpdate(Long competitionId) {
+        // Postgres does not support bind parameters for SET commands, so the
+        // value must be inlined. Safe — hierarchyLockTimeoutMs is a validated positive
+        // int from server configuration (@Value), never derived from request input.
+        entityManager.createNativeQuery(
+            "SET LOCAL lock_timeout = '%dms'".formatted(hierarchyLockTimeoutMs)).executeUpdate();
         return competitionRepository.findByIdForUpdate(competitionId)
             .orElseThrow(() -> new CompetitionNotFoundException(competitionId));
     }
+
+    @Transactional(readOnly = true)
+    public void validateTourDeletionKeepsStageNonEmpty(Long stageId) {
+        Stage stage = stageRepository.findById(stageId)
+            .orElseThrow(() -> new StageNotFoundException(stageId));
+        Competition competition = competitionRepository.findById(stage.getCompetitionId())
+            .orElseThrow(() -> new CompetitionNotFoundException(stage.getCompetitionId()));
+
+        if (competition.getCompetitionStatus() == CompetitionStatus.DRAFT) {
+            return;
+        }
+
+        if (tourRepository.countByStageId(stageId) <= 1) {
+            throw new CompetitionHierarchyValidationException(
+                "Cannot delete tour: it is the last tour of this stage, "
+                    + "and the competition has already left DRAFT status.");
+        }
+    }
 }

src/main/resources/application-test.yml

@@ -0,0 +1,51 @@
+spring:
+  datasource:
+    url: jdbc:postgresql://localhost:5432/test_dummy
+    username: test
+    password: test
+
+  liquibase:
+    enabled: true
+    change-log: classpath:db/changelog/db.changelog-master.xml
+    drop-first: true
+
+  jpa:
+    show-sql: true
+    hibernate:
+      ddl-auto: validate
+    properties:
+      jakarta:
+        persistence:
+          lock:
+            timeout: 500
+
+  mail:
+    username: dummy@test.com
+    password: dummyPassword
+
+  security:
+    oauth2:
+      client:
+        registration:
+          google:
+            client-id: dummy-google-id
+            client-secret: dummy-google-secret
+          microsoft:
+            client-id: dummy-microsoft-id
+            client-secret: dummy-microsoft-secret
+
+jwt:
+  encrypted-key: dummyEncryptedKey1234567890123456
+  sign-key: dummySignKey123456789012345678901234567890
+
+graph:
+  tenant-id: dummy-tenant
+  client-id: dummy-client
+  client-secret: dummy-secret
+  drive-id: dummy-drive
+
+web_client:
+  origin: http://localhost:3000
+
+competition:
+  hierarchy-lock-timeout-ms: ${LOCK_TIMEOUT:1000}

src/main/resources/application.yaml

@@ -151,3 +151,6 @@ app:
     blacklist:
       - JWT_SIGN_KEY
       - JWT_ENCRYPTED_KEY
+
+competition:
+  hierarchy-lock-timeout-ms: ${LOCK_TIMEOUT:3000}

src/test/java/com/itasocialacademy/oitassist/PostgresIntegrationTest.java

@@ -0,0 +1,22 @@
+package com.itasocialacademy.oitassist;
+
+import org.junit.jupiter.api.Tag;
+import org.springframework.boot.test.context.SpringBootTest;
+import org.springframework.boot.testcontainers.service.connection.ServiceConnection;
+import org.springframework.test.context.ActiveProfiles;
+import org.testcontainers.containers.PostgreSQLContainer;
+import org.testcontainers.utility.DockerImageName;
+
+@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.NONE)
+@ActiveProfiles("test")
+@Tag("integration")
+public abstract class PostgresIntegrationTest {
+
+    @ServiceConnection
+    static final PostgreSQLContainer<?> POSTGRES =
+        new PostgreSQLContainer<>(DockerImageName.parse("postgres:16-alpine"));
+
+    static {
+        POSTGRES.start();
+    }
+}

src/test/java/com/itasocialacademy/oitassist/competition/service/CompetitionLockTimeoutIT.java

@@ -0,0 +1,124 @@
+package com.itasocialacademy.oitassist.competition.service;
+
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import com.itasocialacademy.oitassist.PostgresIntegrationTest;
+import com.itasocialacademy.oitassist.competition.dao.enums.CompetitionStatus;
+import com.itasocialacademy.oitassist.competition.dao.enums.ExecutionStatus;
+import com.itasocialacademy.oitassist.competition.dao.enums.StageScope;
+import com.itasocialacademy.oitassist.competition.dao.enums.StageStatus;
+import com.itasocialacademy.oitassist.competition.dao.model.Competition;
+import com.itasocialacademy.oitassist.competition.dao.model.Stage;
+import com.itasocialacademy.oitassist.competition.dao.model.Tour;
+import com.itasocialacademy.oitassist.competition.dao.repository.CompetitionRepository;
+import com.itasocialacademy.oitassist.competition.dao.repository.StageRepository;
+import com.itasocialacademy.oitassist.competition.dao.repository.TourRepository;
+import com.itasocialacademy.oitassist.competition.dto.request.ChangeCompetitionStatusRequest;
+import com.itasocialacademy.oitassist.competition.service.interfaces.CompetitionService;
+import jakarta.persistence.EntityManager;
+import jakarta.persistence.LockModeType;
+import jakarta.persistence.PersistenceContext;
+import java.time.ZonedDateTime;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Test;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.dao.PessimisticLockingFailureException;
+import org.springframework.orm.jpa.JpaTransactionManager;
+import org.springframework.transaction.support.TransactionTemplate;
+
+class CompetitionLockTimeoutIT extends PostgresIntegrationTest {
+
+    @PersistenceContext
+    private EntityManager entityManager;
+    @Autowired
+    private JpaTransactionManager transactionManager;
+    @Autowired
+    private CompetitionRepository competitionRepository;
+    @Autowired
+    private StageRepository stageRepository;
+    @Autowired
+    private TourRepository tourRepository;
+    @Autowired
+    private CompetitionService competitionService;
+
+    private ExecutorService executor;
+
+    @AfterEach
+    void tearDown() {
+        if (executor != null) {
+            executor.shutdownNow();
+        }
+    }
+
+    @Test
+    void lockHeldLongerThanTimeout_shouldSurfaceAsPessimisticLockingFailure() throws Exception {
+        executor = Executors.newFixedThreadPool(1);
+
+        Competition competition = competitionRepository.save(Competition.builder()
+            .title("Timeout Test")
+            .dateStart(ZonedDateTime.now().plusDays(1))
+            .dateFinish(ZonedDateTime.now().plusDays(10))
+            .competitionStatus(CompetitionStatus.DRAFT)
+            .createdBy(1L)
+            .build());
+
+        Stage stage = stageRepository.save(Stage.builder()
+            .competitionId(competition.getId())
+            .title("Stage")
+            .dateStart(competition.getDateStart())
+            .dateFinish(competition.getDateFinish())
+            .sortPosition((short) 1)
+            .scope(StageScope.CITY)
+            .status(StageStatus.SCHEDULED)
+            .createdBy(1L)
+            .build());
+
+        tourRepository.save(Tour.builder()
+            .stageId(stage.getId())
+            .title("Tour")
+            .dateStart(competition.getDateStart())
+            .dateFinish(competition.getDateFinish())
+            .sortPosition((short) 1)
+            .executionStatus(ExecutionStatus.SCHEDULED)
+            .location("location")
+            .createdBy(1L)
+            .build());
+
+        TransactionTemplate holderTx = new TransactionTemplate(transactionManager);
+        CountDownLatch lockAcquired = new CountDownLatch(1);
+        CountDownLatch releaseHolder = new CountDownLatch(1);
+
+        Future<?> holderFuture = executor.submit(() -> holderTx.executeWithoutResult(_ -> {
+            entityManager.find(Competition.class, competition.getId(), LockModeType.PESSIMISTIC_WRITE);
+
+            lockAcquired.countDown();
+            try {
+                releaseHolder.await();
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                throw new RuntimeException(e);
+            }
+        }));
+
+        assertTrue(lockAcquired.await(5, TimeUnit.SECONDS), "Holder thread should acquire the lock");
+
+        ChangeCompetitionStatusRequest request =
+            new ChangeCompetitionStatusRequest(CompetitionStatus.ENROLLMENT, competition.getVersion());
+
+        Long id = competition.getId();
+        assertNotNull(id);
+
+        assertThrows(PessimisticLockingFailureException.class,
+            () -> competitionService.changeStatus(id, request));
+
+        releaseHolder.countDown();
+        holderFuture.get(5, TimeUnit.SECONDS);
+    }
+}