Hotfix/expired credential status schedule task (#54)

* implemented scheduler

* tests

* updated impl and tests with Procedure

* build gradle and changelog

* logs

* changelog

* task updates updated_at

* fix condition

* changed cron

* fix action?

* PR fixes

* PR fixes

* changed test cron

* fix PR

Author: polcaparrosin2

CHANGELOG.md

@@ -4,7 +4,11 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## [v1.2.1](https://github.com/in2workspace/in2-issuer-api/releases/tag/v1.1.4)
+## [v1.2.2](https://github.com/in2workspace/in2-issuer-api/releases/tag/v1.2.2)
+### Added
+- Add scheduled task to set EXPIRED status to credentials that have expired.
+
+## [v1.2.1](https://github.com/in2workspace/in2-issuer-api/releases/tag/v1.2.1)
 ### Added
 - Add support for requesting a fresh QR code if the previous one has expired or was an error during the proccess of
 

build.gradle

@@ -11,7 +11,7 @@ plugins {
 }
 
 group = 'es.in2'
-version = '1.2.1'
+version = '1.2.2'
 
 java {
     sourceCompatibility = '17'

src/main/java/es/in2/issuer/IssuerApiApplication.java

@@ -7,9 +7,11 @@
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.boot.context.properties.ConfigurationPropertiesScan;
 import org.springframework.context.annotation.Bean;
+import org.springframework.scheduling.annotation.EnableScheduling;
 
 @SpringBootApplication
 @ConfigurationPropertiesScan
+@EnableScheduling
 public class IssuerApiApplication {
 
     private static final ObjectMapper OBJECT_MAPPER =

src/main/java/es/in2/issuer/application/scheduler/CredentialExpirationScheduler.java

@@ -0,0 +1,6 @@
+package es.in2.issuer.application.scheduler;
+import reactor.core.publisher.Mono;
+
+public interface CredentialExpirationScheduler {
+    Mono<Void> checkAndExpireCredentials();
+}

src/main/java/es/in2/issuer/application/scheduler/CredentialExpirationSchedulerImpl.java

@@ -0,0 +1,52 @@
+package es.in2.issuer.application.scheduler;
+
+import es.in2.issuer.domain.model.entities.CredentialProcedure;
+import es.in2.issuer.domain.model.enums.CredentialStatus;
+import es.in2.issuer.infrastructure.repository.CredentialProcedureRepository;
+import lombok.RequiredArgsConstructor;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.scheduling.annotation.EnableScheduling;
+import org.springframework.scheduling.annotation.Scheduled;
+import org.springframework.stereotype.Component;
+import reactor.core.publisher.Mono;
+import java.sql.Timestamp;
+import java.time.Instant;
+
+@Component
+@Slf4j
+@EnableScheduling
+@RequiredArgsConstructor
+public class CredentialExpirationSchedulerImpl implements CredentialExpirationScheduler {
+
+    private final CredentialProcedureRepository credentialProcedureRepository;
+
+    @Override
+    @Scheduled(cron = "0 0 1 * * ?") //Every day at 1:00 AM
+    public Mono<Void> checkAndExpireCredentials() {
+        log.info("Scheduled Task - Executing checkAndExpireCredentials at: {}", Instant.now());
+
+        return credentialProcedureRepository.findAll()
+                .flatMap(credential -> isExpired(credential)
+                        .filter(Boolean::booleanValue)
+                        .flatMap(expired -> expireCredential(credential)))
+                .then();
+    }
+
+    private Mono<Boolean> isExpired(CredentialProcedure credentialProcedure) {
+        return Mono.justOrEmpty(credentialProcedure.getValidUntil())
+                .map(validUntil -> validUntil.toInstant().isBefore(Instant.now()))
+                .defaultIfEmpty(false);
+    }
+
+    Mono<CredentialProcedure> expireCredential(CredentialProcedure credentialProcedure) {
+        if(credentialProcedure.getCredentialStatus() != CredentialStatus.EXPIRED) {
+            credentialProcedure.setCredentialStatus(CredentialStatus.EXPIRED);
+            credentialProcedure.setUpdatedAt(Timestamp.from(Instant.now()));
+            log.info("Expiring credential with ID: {} - New state: {}",
+                    credentialProcedure.getCredentialId(),
+                    credentialProcedure.getCredentialStatus());
+            return credentialProcedureRepository.save(credentialProcedure);
+        }
+        return Mono.empty();
+    }
+}

src/test/java/es/in2/issuer/application/scheduler/CredentialExpirationSchedulerImplTest.java

@@ -0,0 +1,84 @@
+package es.in2.issuer.application.scheduler;
+
+import es.in2.issuer.domain.model.entities.CredentialProcedure;
+import es.in2.issuer.domain.model.enums.CredentialStatus;
+import es.in2.issuer.infrastructure.repository.CredentialProcedureRepository;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+import reactor.test.StepVerifier;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+
+import java.sql.Timestamp;
+import java.time.Instant;
+
+import static org.mockito.Mockito.*;
+
+class CredentialExpirationSchedulerImplTest {
+
+    @Mock
+    private CredentialProcedureRepository credentialProcedureRepository;
+
+    @Mock
+    private ObjectMapper objectMapper;
+
+    @InjectMocks
+    private CredentialExpirationSchedulerImpl scheduler;
+
+    @BeforeEach
+    void setUp() {
+        MockitoAnnotations.openMocks(this);
+    }
+
+    @Test
+    void shouldExpireCredentialsWhenValidUntilHasPassed() {
+        CredentialProcedure credential = new CredentialProcedure();
+        credential.setCredentialId(java.util.UUID.randomUUID());
+        credential.setCredentialStatus(CredentialStatus.VALID);
+        credential.setValidUntil(Timestamp.from(Instant.now().minusSeconds(60)));
+
+        when(credentialProcedureRepository.findAll()).thenReturn(Flux.just(credential));
+        when(credentialProcedureRepository.save(any(CredentialProcedure.class)))
+                .thenAnswer(invocation -> Mono.just(invocation.getArgument(0)));
+
+        StepVerifier.create(scheduler.checkAndExpireCredentials())
+                .expectSubscription()
+                .verifyComplete();
+
+        verify(credentialProcedureRepository, atLeastOnce()).save(argThat(updatedCredential -> {
+            boolean statusCorrect = updatedCredential.getCredentialStatus() == CredentialStatus.EXPIRED;
+            boolean updatedAtNotNull = updatedCredential.getUpdatedAt() != null;
+            boolean updatedAtRecent = updatedCredential.getUpdatedAt().toInstant().isAfter(Instant.now().minusSeconds(10));
+
+            return statusCorrect && updatedAtNotNull && updatedAtRecent;
+        }));
+    }
+
+    @Test
+    void shouldNotExpireCredentialsIfValidUntilHasNotPassed() {
+        CredentialProcedure credential = new CredentialProcedure();
+        credential.setCredentialId(java.util.UUID.randomUUID());
+        credential.setCredentialStatus(CredentialStatus.VALID);
+        credential.setValidUntil(Timestamp.from(Instant.now().plusSeconds(60)));
+
+        when(credentialProcedureRepository.findAll()).thenReturn(Flux.just(credential));
+        when(credentialProcedureRepository.save(any(CredentialProcedure.class)))
+                .thenAnswer(invocation -> Mono.just(invocation.getArgument(0)));
+
+        StepVerifier.create(scheduler.checkAndExpireCredentials())
+                .expectSubscription()
+                .verifyComplete();
+
+        verify(credentialProcedureRepository, never()).save(any(CredentialProcedure.class));
+
+        assertEquals(CredentialStatus.VALID, credential.getCredentialStatus());
+        assertNull(credential.getUpdatedAt());
+    }
+}