feat: order content from database (#139)

* feat: order content from database

* fix: use lowest interface possible

* FIX: @order on SuperUser aspect

* FIX: EntityListener instead of AOP for SuperUser

---------

Co-authored-by: brian-mulier <[email protected]>

Author: z06lsouc

tzatziki-spring-jpa/README.md

@@ -163,6 +163,16 @@ Then content is the User entities
 
 The `content` variable created will be a List created from `org.springframework.data.repository.CrudRepository#findAll` 
 
+For both you can order the List fetched from the database (direction is not mandatory and defaults to ascending)
+```gherkin
+Then content is the users table content ordered by date_of_birth desc and date_of_death
+
+# or alternatively
+Then content is the User entities ordered by date_of_birth desc and date_of_death
+```
+
+The `content` variable created will be a List created from `org.springframework.data.jpa.repository.JpaRepository#findAll(Sort)`
+
 ## Resetting the database between tests
 
 The library will automatically reset the database between each test. 

tzatziki-spring-jpa/src/main/java/com/decathlon/tzatziki/steps/SpringJPASteps.java

@@ -9,14 +9,17 @@
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.data.domain.Sort;
 import org.springframework.data.repository.CrudRepository;
+import org.springframework.data.repository.PagingAndSortingRepository;
 import org.springframework.jdbc.core.JdbcTemplate;
 import org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean;
 
 import javax.persistence.Table;
 import javax.sql.DataSource;
 import java.lang.reflect.Type;
 import java.lang.reflect.TypeVariable;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
@@ -32,6 +35,9 @@
 
 public class SpringJPASteps {
 
+    public static final String ORDER_PATTERN = "[a-zA-Z]+(?: asc| desc)?";
+    public static final String ORDER_SEPARATOR = " and ";
+
     static {
         DynamicTransformers.register(Type.class, TypeParser::parse);
         DynamicTransformers.register(InsertionMode.class, InsertionMode::parse);
@@ -69,7 +75,7 @@ public void before() {
                     .stream()
                     .map(crudRepository -> Map.entry(crudRepository, TypeUtils.getTypeArguments(crudRepository.getClass(), CrudRepository.class).get(CrudRepository.class.getTypeParameters()[0])))
                     .sorted((e1, e2) -> {
-                        if(e1.getValue() instanceof Class) return -1;
+                        if (e1.getValue() instanceof Class) return -1;
                         return e2.getValue() instanceof Class ? 1 : 0;
                     })
                     .<Map.Entry<Class<?>, CrudRepository<?, ?>>>mapMulti((crudRepositoryWithType, consumer) -> {
@@ -175,6 +181,27 @@ public void add_entities_to_variable(Guard guard, String name, Type type) {
         add_repository_content_to_variable(guard, name, getRepositoryForEntity(type));
     }
 
+
+    @Then(THAT + GUARD + VARIABLE + " is the ([^ ]+) table content ordered by (" + ORDER_PATTERN + "(?:" + ORDER_SEPARATOR + ORDER_PATTERN + ")*)$")
+    public void add_ordered_table_content_to_variable(Guard guard, String name, String table, String orders) {
+        add_ordered_repository_content_to_variable(guard, name, getRepositoryForTable(table), parseSort(orders));
+    }
+
+    @Then(THAT + GUARD + VARIABLE + " is the " + TYPE + " entities ordered by (" + ORDER_PATTERN + "(?:" + ORDER_SEPARATOR + ORDER_PATTERN + ")*)$")
+    public void add_ordered_entities_to_variable(Guard guard, String name, Type type, String orders) {
+        add_ordered_repository_content_to_variable(guard, name, getRepositoryForEntity(type), parseSort(orders));
+    }
+
+    @NotNull
+    private Sort parseSort(String orders) {
+        return Sort.by(Arrays.stream(orders.split(ORDER_SEPARATOR)).map(this::parseOrder).toList());
+    }
+
+    private Sort.Order parseOrder(String propertyAndDirection) {
+        String[] elmts = propertyAndDirection.split(" ");
+        return elmts.length > 1 ? new Sort.Order(Sort.Direction.fromString(elmts[1]), elmts[0]) : Sort.Order.by(elmts[0]);
+    }
+
     private void the_repository_contains_nothing(Guard guard, CrudRepository<Object, ?> repositoryOfEntity) {
         guard.in(objects, () -> assertThat(repositoryOfEntity.count()).isZero());
     }
@@ -220,6 +247,15 @@ public <E> void add_repository_content_to_variable(Guard guard, String name, Cru
         guard.in(objects, () -> objects.add(name, StreamSupport.stream(repository.findAll().spliterator(), false).toList()));
     }
 
+    @SuppressWarnings("unchecked")
+    public <E> void add_ordered_repository_content_to_variable(Guard guard, String name, CrudRepository<E, ?> repository, Sort sort) {
+        if (repository instanceof PagingAndSortingRepository sortingRepository) {
+            guard.in(objects, () -> objects.add(name, StreamSupport.stream(sortingRepository.findAll(sort).spliterator(), false).toList()));
+        } else {
+            throw new AssertionError(repository.getClass() + " is not a PagingAndSortingRepository!");
+        }
+    }
+
     public <E> CrudRepository<E, ?> getRepositoryForTable(String table) {
         return getRepositoryForEntity(Optional.ofNullable(this.entityClassByTableName.get(table)).orElseGet(() -> TypeParser.parse(table)));
     }

tzatziki-spring-jpa/src/test/java/com/decathlon/tzatziki/app/aspects/SuperUserCrudSavePrefixerAspect.java

@@ -1,6 +1,6 @@
 package com.decathlon.tzatziki.app.dao;
 
 import com.decathlon.tzatziki.app.model.User;
-import org.springframework.data.repository.CrudRepository;
+import org.springframework.data.jpa.repository.JpaRepository;
 
-public interface UserDataSpringRepository<T extends User> extends CrudRepository<T, Integer> {}
+public interface UserDataSpringRepository<T extends User> extends JpaRepository<T, Integer> {}

tzatziki-spring-jpa/src/test/java/com/decathlon/tzatziki/app/dao/UserDataSpringRepository.java

@@ -0,0 +1,12 @@
+package com.decathlon.tzatziki.app.entity_listeners;
+
+import com.decathlon.tzatziki.app.model.SuperUser;
+
+import javax.persistence.PrePersist;
+
+public class SuperUserEntityListener {
+    @PrePersist
+    public void addPrefixToRoles(SuperUser superUser) {
+        superUser.setRole("superUser_" + superUser.getRole());
+    }
+}

tzatziki-spring-jpa/src/test/java/com/decathlon/tzatziki/app/entity_listeners/SuperUserEntityListener.java

@@ -1,17 +1,20 @@
 package com.decathlon.tzatziki.app.model;
 
+import com.decathlon.tzatziki.app.entity_listeners.SuperUserEntityListener;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
 
 import javax.persistence.Column;
 import javax.persistence.Entity;
+import javax.persistence.EntityListeners;
 import javax.persistence.Table;
 
 @Getter
 @Entity
 @NoArgsConstructor
 @Table(name = "super_users")
+@EntityListeners(SuperUserEntityListener.class)
 public class SuperUser extends User {
     @Setter
     @Column(name = "role")

tzatziki-spring-jpa/src/test/java/com/decathlon/tzatziki/app/model/SuperUser.java

@@ -190,6 +190,58 @@ Feature: to interact with a spring boot service having a persistence layer
       | 1  | Darth     | Vader    |
       | 2  | Han       | Solo     |
 
+  Scenario: we can get a table content ordered
+    Given that the users table will contain only:
+      | id | firstName | lastName | birthDate                                         | updatedAt    |
+      | 1  | Darth     | Vader    | {{{[@41 years before The 19th of october 1977]}}} | {{{[@now]}}} |
+      | 2  | Han       | Solo     | {{{[@32 years before The 19th of october 1977]}}} | {{{[@now]}}} |
+    Then usersTableContent is the users table content ordered by lastName
+    And usersTableContent contains only and in order:
+      | id | firstName | lastName |
+      | 2  | Han       | Solo     |
+      | 1  | Darth     | Vader    |
+    Then usersTableContent is the users table content ordered by birthDate
+    And usersTableContent contains only and in order:
+      | id | firstName | lastName |
+      | 1  | Darth     | Vader    |
+      | 2  | Han       | Solo     |
+    Then usersTableContent is the users table content ordered by birthDate desc
+    And usersTableContent contains only and in order:
+      | id | firstName | lastName |
+      | 2  | Han       | Solo     |
+      | 1  | Darth     | Vader    |
+    Then usersTableContent is the users table content ordered by updatedAt and birthDate desc
+    And usersTableContent contains only and in order:
+      | id | firstName | lastName |
+      | 2  | Han       | Solo     |
+      | 1  | Darth     | Vader    |
+
+  Scenario: we can get entities ordered
+    Given that the User entities will contain only:
+      | id | firstName | lastName | birthDate                                         | updatedAt    |
+      | 1  | Darth     | Vader    | {{{[@41 years before The 19th of october 1977]}}} | {{{[@now]}}} |
+      | 2  | Han       | Solo     | {{{[@32 years before The 19th of october 1977]}}} | {{{[@now]}}} |
+    Then userEntities is the User entities ordered by lastName
+    And userEntities contains only and in order:
+      | id | firstName | lastName |
+      | 2  | Han       | Solo     |
+      | 1  | Darth     | Vader    |
+    Then userEntities is the User entities ordered by birthDate
+    And userEntities contains only and in order:
+      | id | firstName | lastName |
+      | 1  | Darth     | Vader    |
+      | 2  | Han       | Solo     |
+    Then userEntities is the User entities ordered by birthDate desc
+    And userEntities contains only and in order:
+      | id | firstName | lastName |
+      | 2  | Han       | Solo     |
+      | 1  | Darth     | Vader    |
+    Then userEntities is the User entities ordered by updatedAt and birthDate desc
+    And userEntities contains only and in order:
+      | id | firstName | lastName |
+      | 2  | Han       | Solo     |
+      | 1  | Darth     | Vader    |
+
   Scenario: there shouldn't be any "within" implicit guard in JPA assertions
     Given that after 100ms the User entities will contain only:
       | id | firstName | lastName |