From 761baad8e54492ac8bc40ff5337d121b09a96f46 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Tue, 24 Jun 2025 19:09:21 +0100 Subject: [PATCH 01/33] feat: update the code on Restriction Converter to return the proper type updated from Jakarta Data Signed-off-by: Otavio Santana --- .../semistructured/query/RestrictionConverter.java | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/RestrictionConverter.java b/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/RestrictionConverter.java index 1f084b34e..ced174be3 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/RestrictionConverter.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/RestrictionConverter.java @@ -14,14 +14,14 @@ */ package org.eclipse.jnosql.mapping.semistructured.query; +import jakarta.data.constraint.AtLeast; +import jakarta.data.constraint.AtMost; import jakarta.data.constraint.Between; import jakarta.data.constraint.Constraint; import jakarta.data.constraint.EqualTo; import jakarta.data.constraint.GreaterThan; -import jakarta.data.constraint.GreaterThanOrEqual; import jakarta.data.constraint.In; import jakarta.data.constraint.LessThan; -import jakarta.data.constraint.LessThanOrEqual; import jakarta.data.constraint.Like; import jakarta.data.constraint.NotBetween; import jakarta.data.constraint.NotEqualTo; @@ -152,13 +152,13 @@ private CriteriaCondition condition(BasicAttribute basicAttribute, Constra return gt(name, value); } - case GreaterThanOrEqual greaterThanOrEqual -> { + case AtLeast greaterThanOrEqual -> { var value = ValueConverter.of(greaterThanOrEqual::bound, basicAttribute, converters, converter.orElse(null), fieldMetadata.orElse(null)); return gte(name, value); } - case LessThanOrEqual lesserThanOrEqual -> { + case AtMost lesserThanOrEqual -> { var value = ValueConverter.of(lesserThanOrEqual::bound, basicAttribute, converters, converter.orElse(null), fieldMetadata.orElse(null)); return lte(name, value); From 94b065d26176c274254677ee883892b0454bbea8 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Wed, 25 Jun 2025 07:10:48 +0100 Subject: [PATCH 02/33] test: generate structure on at Least Signed-off-by: Otavio Santana --- .../query/CrudRepositoryProxyIsTest.java | 153 ++++++++++++++++++ 1 file changed, 153 insertions(+) create mode 100644 jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CrudRepositoryProxyIsTest.java diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CrudRepositoryProxyIsTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CrudRepositoryProxyIsTest.java new file mode 100644 index 000000000..b2eb3123a --- /dev/null +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CrudRepositoryProxyIsTest.java @@ -0,0 +1,153 @@ +/* + * Copyright (c) 2022 Contributors to the Eclipse Foundation + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * and Apache License v2.0 which accompanies this distribution. + * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html + * and the Apache License v2.0 is available at http://www.opensource.org/licenses/apache2.0.php. + * + * You may elect to redistribute this code under either of these licenses. + * + * Contributors: + * + * Otavio Santana + */ +package org.eclipse.jnosql.mapping.semistructured.query; + +import jakarta.data.Order; +import jakarta.data.Sort; +import jakarta.data.constraint.GreaterThan; +import jakarta.data.page.CursoredPage; +import jakarta.data.page.Page; +import jakarta.data.page.PageRequest; +import jakarta.data.repository.By; +import jakarta.data.repository.CrudRepository; +import jakarta.data.repository.Delete; +import jakarta.data.repository.Find; +import jakarta.data.repository.Is; +import jakarta.data.repository.OrderBy; +import jakarta.data.repository.Param; +import jakarta.data.repository.Query; +import jakarta.data.restrict.Restriction; +import jakarta.inject.Inject; +import org.assertj.core.api.SoftAssertions; +import org.eclipse.jnosql.communication.Condition; +import org.eclipse.jnosql.communication.TypeReference; +import org.eclipse.jnosql.communication.semistructured.CriteriaCondition; +import org.eclipse.jnosql.communication.semistructured.DeleteQuery; +import org.eclipse.jnosql.communication.semistructured.Element; +import org.eclipse.jnosql.communication.semistructured.SelectQuery; +import org.eclipse.jnosql.mapping.core.Converters; +import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata; +import org.eclipse.jnosql.mapping.reflection.Reflections; +import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; +import org.eclipse.jnosql.mapping.semistructured.EntityConverter; +import org.eclipse.jnosql.mapping.semistructured.MockProducer; +import org.eclipse.jnosql.mapping.semistructured.SemiStructuredTemplate; +import org.eclipse.jnosql.mapping.semistructured.entities.Product; +import org.eclipse.jnosql.mapping.semistructured.entities._Product; +import org.jboss.weld.junit5.auto.AddExtensions; +import org.jboss.weld.junit5.auto.AddPackages; +import org.jboss.weld.junit5.auto.EnableAutoWeld; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mockito.ArgumentCaptor; +import org.mockito.Mockito; + +import java.lang.reflect.Proxy; +import java.math.BigDecimal; +import java.util.List; +import java.util.stream.Stream; + +import static org.eclipse.jnosql.communication.Condition.AND; +import static org.eclipse.jnosql.communication.Condition.EQUALS; +import static org.eclipse.jnosql.communication.Condition.GREATER_THAN; +import static org.mockito.Mockito.any; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +@EnableAutoWeld +@AddPackages(value = {Converters.class, EntityConverter.class}) +@AddPackages(MockProducer.class) +@AddPackages(Reflections.class) +@AddExtensions({ReflectionEntityMetadataExtension.class}) +class CrudRepositoryProxyIsTest { + + private SemiStructuredTemplate template; + + @Inject + private EntitiesMetadata entities; + + @Inject + private Converters converters; + + private ProductRepository repository; + + + @BeforeEach + public void setUp() { + this.template = Mockito.mock(SemiStructuredTemplate.class); + + var productHandler = new SemiStructuredRepositoryProxy<>(template, + entities, ProductRepository.class, converters); + + + + repository = (ProductRepository) Proxy.newProxyInstance(ProductRepository.class.getClassLoader(), + new Class[]{ProductRepository.class}, + productHandler); + } + + + @Test + void shouldEquals() { + + when(template.select(any(SelectQuery.class))) + .thenReturn(Stream.of(new Product())); + + repository.equals("Mac"); + ArgumentCaptor captor = ArgumentCaptor.forClass(SelectQuery.class); + verify(template).select(captor.capture()); + SelectQuery query = captor.getValue(); + + SoftAssertions.assertSoftly(softly -> { + softly.assertThat(query.name()).isEqualTo("Product"); + softly.assertThat(query.condition()).isPresent(); + CriteriaCondition condition = query.condition().orElseThrow(); + softly.assertThat(condition).isInstanceOf(CriteriaCondition.class); + softly.assertThat(condition.condition()).isEqualTo(EQUALS); + softly.assertThat(condition.element()).isEqualTo(Element.of(_Product.NAME, "Mac")); + }); + } + + @Test + void shouldAtLeast() { + + when(template.select(any(SelectQuery.class))) + .thenReturn(Stream.of(new Product())); + + repository.greaterThan(BigDecimal.TEN); + ArgumentCaptor captor = ArgumentCaptor.forClass(SelectQuery.class); + verify(template).select(captor.capture()); + SelectQuery query = captor.getValue(); + + SoftAssertions.assertSoftly(softly -> { + softly.assertThat(query.name()).isEqualTo("Product"); + softly.assertThat(query.condition()).isPresent(); + CriteriaCondition condition = query.condition().orElseThrow(); + softly.assertThat(condition).isInstanceOf(CriteriaCondition.class); + softly.assertThat(condition.condition()).isEqualTo(GREATER_THAN); + softly.assertThat(condition.element()).isEqualTo(Element.of(_Product.PRICE, BigDecimal.TEN)); + }); + } + + + public interface ProductRepository extends CrudRepository { + @Find + List equals(@By(_Product.NAME) @Is String name); + + @Find + List greaterThan(@By(_Product.PRICE) @Is(GreaterThan.class) BigDecimal price); + } + +} From d9e587d00e863c5a245f700e1bb1dfd608242de2 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Wed, 25 Jun 2025 07:20:42 +0100 Subject: [PATCH 03/33] feat: update ParamValue to return value Signed-off-by: Otavio Santana --- .../core/repository/RepositoryReflectionUtils.java | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtils.java b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtils.java index c67fb0a82..eeb798722 100644 --- a/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtils.java +++ b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtils.java @@ -19,7 +19,9 @@ import jakarta.data.repository.By; import jakarta.data.repository.Param; import jakarta.data.repository.Query; +import org.eclipse.jnosql.communication.Condition; +import java.io.Serializable; import java.lang.reflect.Method; import java.lang.reflect.Parameter; import java.util.HashMap; @@ -61,6 +63,13 @@ public Map getParams(Method method, Object[] args) { return params; } + /** + * Represents a parameter value with its condition. + * It will get the {@link Param} value and combine it with {@link jakarta.data.repository.Is} + * by default if does not have {@link jakarta.data.repository.Is} it will use {@link Condition#EQUALS}. + */ + public record ParamValue(Condition condition, Object value){} + /** * Converts values at arg at a {@link Map} * From 798f6b4f6a9d6ba7272443ef3e2c30322548c51f Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Wed, 25 Jun 2025 07:44:00 +0100 Subject: [PATCH 04/33] feat: update structure to verson on ParamValue Signed-off-by: Otavio Santana --- .../repository/RepositoryReflectionUtils.java | 51 +++++++++++++++---- 1 file changed, 40 insertions(+), 11 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtils.java b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtils.java index eeb798722..ed0bb706d 100644 --- a/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtils.java +++ b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtils.java @@ -16,7 +16,10 @@ +import jakarta.data.constraint.AtLeast; +import jakarta.data.constraint.Constraint; import jakarta.data.repository.By; +import jakarta.data.repository.Is; import jakarta.data.repository.Param; import jakarta.data.repository.Query; import org.eclipse.jnosql.communication.Condition; @@ -63,13 +66,6 @@ public Map getParams(Method method, Object[] args) { return params; } - /** - * Represents a parameter value with its condition. - * It will get the {@link Param} value and combine it with {@link jakarta.data.repository.Is} - * by default if does not have {@link jakarta.data.repository.Is} it will use {@link Condition#EQUALS}. - */ - public record ParamValue(Condition condition, Object value){} - /** * Converts values at arg at a {@link Map} * @@ -77,23 +73,56 @@ public record ParamValue(Condition condition, Object value){} * @param args the arguments from the method * @return the {@link Map} from method and its arguments */ - public Map getBy(Method method, Object[] args) { - Map params = new HashMap<>(); + public Map getBy(Method method, Object[] args) { + Map params = new HashMap<>(); Parameter[] parameters = method.getParameters(); for (int index = 0; index < parameters.length; index++) { Parameter parameter = parameters[index]; boolean isNotSpecialParameter = SpecialParameters.isNotSpecialParameter(parameter.getType()); By by = parameter.getAnnotation(By.class); + Is is = parameter.getAnnotation(Is.class); if (Objects.nonNull(by)) { - params.put(by.value(), args[index]); + params.put(by.value(), condition(is, args[index])); } else if(parameter.isNamePresent() && isNotSpecialParameter) { - params.put(parameter.getName(), args[index]); + params.put(parameter.getName(), condition(is,args[index])); } } return params; } + /** + * Represents a parameter value with its condition. + * It will get the {@link Param} value and combine it with {@link jakarta.data.repository.Is} + * by default value is {@link Condition#EQUALS} + */ + public record ParamValue(Condition condition, Object value, boolean negate){} + + public ParamValue condition(Is is, Object value) { + if (Objects.isNull(is)) { + return new ParamValue(Condition.EQUALS, value, false); + } + Class constraint = is.value(); + return switch (constraint.getName()) { + case "jakarta.data.constraint.AtLeast" -> new ParamValue(Condition.GREATER_EQUALS_THAN, value, false); + case "jakarta.data.constraint.AtMost" -> new ParamValue(Condition.LESSER_EQUALS_THAN, value, false); + case "jakarta.data.constraint.GreaterThan" -> new ParamValue(Condition.GREATER_THAN, value, false); + case "jakarta.data.constraint.LesserThan" -> new ParamValue(Condition.LESSER_THAN, value, false); + case "jakarta.data.constraint.Between" -> new ParamValue(Condition.BETWEEN, value, false); + case "jakarta.data.constraint.EqualTo" -> new ParamValue(Condition.EQUALS, value, false); + case "jakarta.data.constraint.Like" -> new ParamValue(Condition.LIKE, value, false); + case "jakarta.data.constraint.In" -> new ParamValue(Condition.IN, value, false); + // Negate conditions + case "jakarta.data.constraint.NotBetween" -> new ParamValue(Condition.BETWEEN, value, true); + case "jakarta.data.constraint.NotEquals" -> new ParamValue(Condition.EQUALS, value, true); + case "jakarta.data.constraint.NotIn" -> new ParamValue(Condition.IN, value, true); + case "jakarta.data.constraint.NotLike" -> new ParamValue(Condition.LIKE, value, true); + default -> throw new UnsupportedOperationException("The FindBy annotation does not support this constraint: " + constraint.getName() + +" at the Is annotation, please use one of the following: " + + "AtLeast, AtMost, GreaterThan, LesserThan, Between, EqualTo, Like, In, NotBetween, NotEquals, NotIn or NotLike"); + }; + } + /** * Returns the query value from the {@link Query} annotation From 8fed51edb457e8694f4d69bd66ff040503c274f7 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Wed, 25 Jun 2025 07:46:58 +0100 Subject: [PATCH 05/33] feat: generate paramvalue to represent param metadata Signed-off-by: Otavio Santana --- .../jnosql/mapping/core/repository/ParamValue.java | 10 ++++++++++ 1 file changed, 10 insertions(+) create mode 100644 jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/ParamValue.java diff --git a/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/ParamValue.java b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/ParamValue.java new file mode 100644 index 000000000..0952134e7 --- /dev/null +++ b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/ParamValue.java @@ -0,0 +1,10 @@ +package org.eclipse.jnosql.mapping.core.repository; + +import org.eclipse.jnosql.communication.Condition; + +/** + * Represents a parameter value with its condition that can be used in repository queries that has the {@link jakarta.data.repository.Find} annotation at method. + * It will get the {@link jakarta.data.repository.Param} to each parameter value and combine it with {@link jakarta.data.repository.Is} + * by default value is {@link Condition#EQUALS} + */ +public record ParamValue(Condition condition, Object value, boolean negate){} \ No newline at end of file From c6cfaf98ed348eeb90bff2c544e1fc2d731036d6 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Wed, 25 Jun 2025 07:48:01 +0100 Subject: [PATCH 06/33] feaet: update structure to paramvalue Signed-off-by: Otavio Santana --- .../mapping/core/repository/RepositoryReflectionUtils.java | 7 ------- 1 file changed, 7 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtils.java b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtils.java index ed0bb706d..5a0315e8c 100644 --- a/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtils.java +++ b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtils.java @@ -91,13 +91,6 @@ public Map getBy(Method method, Object[] args) { return params; } - /** - * Represents a parameter value with its condition. - * It will get the {@link Param} value and combine it with {@link jakarta.data.repository.Is} - * by default value is {@link Condition#EQUALS} - */ - public record ParamValue(Condition condition, Object value, boolean negate){} - public ParamValue condition(Is is, Object value) { if (Objects.isNull(is)) { return new ParamValue(Condition.EQUALS, value, false); From fba4e4a0773260b1b106ccfb38269a8eb29e9052 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 26 Jun 2025 08:41:25 +0100 Subject: [PATCH 07/33] feat: update code scenaion on repository collection Signed-off-by: Otavio Santana --- .../core/repository/RepositoryReflectionUtils.java | 11 ++++++++--- .../repository/RepositoryReflectionUtilsTest.java | 5 +++-- 2 files changed, 11 insertions(+), 5 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtils.java b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtils.java index 5a0315e8c..49484452e 100644 --- a/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtils.java +++ b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtils.java @@ -96,6 +96,10 @@ public ParamValue condition(Is is, Object value) { return new ParamValue(Condition.EQUALS, value, false); } Class constraint = is.value(); + return getParamValue(value, constraint); + } + + static ParamValue getParamValue(Object value, Class constraint) { return switch (constraint.getName()) { case "jakarta.data.constraint.AtLeast" -> new ParamValue(Condition.GREATER_EQUALS_THAN, value, false); case "jakarta.data.constraint.AtMost" -> new ParamValue(Condition.LESSER_EQUALS_THAN, value, false); @@ -110,9 +114,10 @@ public ParamValue condition(Is is, Object value) { case "jakarta.data.constraint.NotEquals" -> new ParamValue(Condition.EQUALS, value, true); case "jakarta.data.constraint.NotIn" -> new ParamValue(Condition.IN, value, true); case "jakarta.data.constraint.NotLike" -> new ParamValue(Condition.LIKE, value, true); - default -> throw new UnsupportedOperationException("The FindBy annotation does not support this constraint: " + constraint.getName() - +" at the Is annotation, please use one of the following: " - + "AtLeast, AtMost, GreaterThan, LesserThan, Between, EqualTo, Like, In, NotBetween, NotEquals, NotIn or NotLike"); + default -> + throw new UnsupportedOperationException("The FindBy annotation does not support this constraint: " + constraint.getName() + + " at the Is annotation, please use one of the following: " + + "AtLeast, AtMost, GreaterThan, LesserThan, Between, EqualTo, Like, In, NotBetween, NotEquals, NotIn or NotLike"); }; } diff --git a/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtilsTest.java b/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtilsTest.java index 15f028aa6..d34647fad 100644 --- a/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtilsTest.java +++ b/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtilsTest.java @@ -18,6 +18,7 @@ import jakarta.data.repository.BasicRepository; import jakarta.data.repository.Param; import jakarta.data.repository.Query; +import org.eclipse.jnosql.communication.Condition; import org.eclipse.jnosql.mapping.core.entities.Person; import org.junit.jupiter.api.Test; @@ -69,10 +70,10 @@ void shouldByWithoutSpecialParams() { Method method = Arrays.stream(PersonRepository.class.getDeclaredMethods()).filter(m -> m.getName().equals("query")) .findFirst().orElseThrow(); final Sort SPECIAL_PARAM = Sort.asc(""); - Map params = RepositoryReflectionUtils.INSTANCE.getBy(method, new Object[]{"Ada", SPECIAL_PARAM}); + Map params = RepositoryReflectionUtils.INSTANCE.getBy(method, new Object[]{"Ada", SPECIAL_PARAM}); assertThat(params) .hasSize(1) - .containsEntry("name", "Ada"); + .containsEntry("name", new ParamValue(Condition.EQUALS, "Ada", false)); } @Test From d66b886787f1cfa1ae8db0e4ead4cd1deccf77ca Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 26 Jun 2025 08:55:25 +0100 Subject: [PATCH 08/33] test: include scenarion to return Signed-off-by: Otavio Santana --- .../repository/RepositoryReflectionUtils.java | 4 +- .../RepositoryReflectionUtilsTest.java | 40 +++++++++++++++++++ 2 files changed, 42 insertions(+), 2 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtils.java b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtils.java index 49484452e..e68d0c46a 100644 --- a/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtils.java +++ b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtils.java @@ -104,14 +104,14 @@ static ParamValue getParamValue(Object value, Class constr case "jakarta.data.constraint.AtLeast" -> new ParamValue(Condition.GREATER_EQUALS_THAN, value, false); case "jakarta.data.constraint.AtMost" -> new ParamValue(Condition.LESSER_EQUALS_THAN, value, false); case "jakarta.data.constraint.GreaterThan" -> new ParamValue(Condition.GREATER_THAN, value, false); - case "jakarta.data.constraint.LesserThan" -> new ParamValue(Condition.LESSER_THAN, value, false); + case "jakarta.data.constraint.LessThan" -> new ParamValue(Condition.LESSER_THAN, value, false); case "jakarta.data.constraint.Between" -> new ParamValue(Condition.BETWEEN, value, false); case "jakarta.data.constraint.EqualTo" -> new ParamValue(Condition.EQUALS, value, false); case "jakarta.data.constraint.Like" -> new ParamValue(Condition.LIKE, value, false); case "jakarta.data.constraint.In" -> new ParamValue(Condition.IN, value, false); // Negate conditions case "jakarta.data.constraint.NotBetween" -> new ParamValue(Condition.BETWEEN, value, true); - case "jakarta.data.constraint.NotEquals" -> new ParamValue(Condition.EQUALS, value, true); + case "jakarta.data.constraint.NotEqualTo" -> new ParamValue(Condition.EQUALS, value, true); case "jakarta.data.constraint.NotIn" -> new ParamValue(Condition.IN, value, true); case "jakarta.data.constraint.NotLike" -> new ParamValue(Condition.LIKE, value, true); default -> diff --git a/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtilsTest.java b/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtilsTest.java index d34647fad..7b7a7dddd 100644 --- a/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtilsTest.java +++ b/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtilsTest.java @@ -14,10 +14,24 @@ */ package org.eclipse.jnosql.mapping.core.repository; +import jakarta.data.constraint.AtLeast; +import jakarta.data.constraint.AtMost; +import jakarta.data.constraint.Between; +import jakarta.data.constraint.Constraint; +import jakarta.data.constraint.EqualTo; +import jakarta.data.constraint.GreaterThan; +import jakarta.data.constraint.In; +import jakarta.data.constraint.LessThan; +import jakarta.data.constraint.Like; +import jakarta.data.constraint.NotBetween; +import jakarta.data.constraint.NotEqualTo; +import jakarta.data.constraint.NotIn; +import jakarta.data.constraint.NotLike; import jakarta.data.repository.By; import jakarta.data.repository.BasicRepository; import jakarta.data.repository.Param; import jakarta.data.repository.Query; +import org.assertj.core.api.SoftAssertions; import org.eclipse.jnosql.communication.Condition; import org.eclipse.jnosql.mapping.core.entities.Person; import org.junit.jupiter.api.Test; @@ -32,6 +46,8 @@ import static org.junit.jupiter.api.Assertions.*; import jakarta.data.Sort; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.ValueSource; class RepositoryReflectionUtilsTest { @@ -127,6 +143,30 @@ void shouldFindByAgeAndNameWithParams() { .containsEntry("name", "Ada"); } + + @ParameterizedTest(name = "Testing positive {index} - {0}") + @ValueSource(classes = {AtLeast.class, AtMost.class, GreaterThan.class, LessThan.class, Between.class, + EqualTo.class, Like.class, In.class}) + void shouldGetParamValueByPositive(Class> constraint) { + ParamValue paramValue = RepositoryReflectionUtils.getParamValue("name", constraint); + + SoftAssertions.assertSoftly(softly -> { + softly.assertThat(paramValue.value()).isEqualTo("name"); + softly.assertThat(paramValue.negate()).isFalse(); + }); + } + + @ParameterizedTest(name = "Negative positive {index} - {0}") + @ValueSource(classes = {NotBetween.class, NotEqualTo.class, NotIn.class, NotLike.class}) + void shouldGetParamValueByNegative(Class> constraint) { + ParamValue paramValue = RepositoryReflectionUtils.getParamValue("name", constraint); + + SoftAssertions.assertSoftly(softly -> { + softly.assertThat(paramValue.value()).isEqualTo("name"); + softly.assertThat(paramValue.negate()).isTrue(); + }); + } + interface PersonRepository extends BasicRepository { @Query("FROM Person WHERE name = :name") From ddd44112d5cc685343cfc83cc8e22e21ae619e8c Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 26 Jun 2025 08:56:26 +0100 Subject: [PATCH 09/33] style: include header on ParamValue Signed-off-by: Otavio Santana --- .../jnosql/mapping/core/repository/ParamValue.java | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/ParamValue.java b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/ParamValue.java index 0952134e7..c3dc3d4e8 100644 --- a/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/ParamValue.java +++ b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/ParamValue.java @@ -1,3 +1,17 @@ +/* + * Copyright (c) 2025 Contributors to the Eclipse Foundation + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the Eclipse Public License v1.0 + * and Apache License v2.0 which accompanies this distribution. + * The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html + * and the Apache License v2.0 is available at http://www.opensource.org/licenses/apache2.0.php. + * + * You may elect to redistribute this code under either of these licenses. + * + * Contributors: + * + * Otavio Santana + */ package org.eclipse.jnosql.mapping.core.repository; import org.eclipse.jnosql.communication.Condition; From b54ace63a92ffd6aeef4968c11f1b679eb40e49e Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 26 Jun 2025 08:56:54 +0100 Subject: [PATCH 10/33] style: remove unsed imports at RepositoryReflectionUtils Signed-off-by: Otavio Santana --- .../mapping/core/repository/RepositoryReflectionUtils.java | 3 --- 1 file changed, 3 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtils.java b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtils.java index e68d0c46a..5f39a1a17 100644 --- a/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtils.java +++ b/jnosql-mapping/jnosql-mapping-core/src/main/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtils.java @@ -15,8 +15,6 @@ package org.eclipse.jnosql.mapping.core.repository; - -import jakarta.data.constraint.AtLeast; import jakarta.data.constraint.Constraint; import jakarta.data.repository.By; import jakarta.data.repository.Is; @@ -24,7 +22,6 @@ import jakarta.data.repository.Query; import org.eclipse.jnosql.communication.Condition; -import java.io.Serializable; import java.lang.reflect.Method; import java.lang.reflect.Parameter; import java.util.HashMap; From d6bd444824d16efd3d5847f3a94ad74a1aecb2e8 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Fri, 27 Jun 2025 06:27:44 +0100 Subject: [PATCH 11/33] test: include update repository refletions utils Signed-off-by: Otavio Santana --- .../RepositoryReflectionUtilsTest.java | 33 +++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtilsTest.java b/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtilsTest.java index 7b7a7dddd..f65d6bab4 100644 --- a/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtilsTest.java +++ b/jnosql-mapping/jnosql-mapping-core/src/test/java/org/eclipse/jnosql/mapping/core/repository/RepositoryReflectionUtilsTest.java @@ -47,7 +47,10 @@ import jakarta.data.Sort; import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.Arguments; +import org.junit.jupiter.params.provider.MethodSource; import org.junit.jupiter.params.provider.ValueSource; +import org.junit.jupiter.params.provider.ValueSources; class RepositoryReflectionUtilsTest { @@ -167,6 +170,36 @@ void shouldGetParamValueByNegative(Class> constraint) { }); } + + @ParameterizedTest(name = "Testing condition {index} - {0}") + @MethodSource("conditions") + void shouldReturnParam(Class> constraint, boolean isNegate, Condition condition) { + ParamValue paramValue = RepositoryReflectionUtils.getParamValue("name", constraint); + + SoftAssertions.assertSoftly(softly -> { + softly.assertThat(paramValue.condition()).isEqualTo(condition); + softly.assertThat(paramValue.negate()).isEqualTo(isNegate); + softly.assertThat(paramValue.value()).isEqualTo("name"); + }); + } + + public static Stream conditions() { + return Stream.of( + Arguments.of(AtLeast.class, false, Condition.GREATER_EQUALS_THAN), + Arguments.of(AtMost.class, false, Condition.LESSER_EQUALS_THAN), + Arguments.of(GreaterThan.class, false, Condition.GREATER_THAN), + Arguments.of(LessThan.class, false, Condition.LESSER_THAN), + Arguments.of(Between.class, false, Condition.BETWEEN), + Arguments.of(EqualTo.class, false, Condition.EQUALS), + Arguments.of(Like.class, false, Condition.LIKE), + Arguments.of(In.class, false, Condition.IN), + Arguments.of(NotBetween.class, true, Condition.BETWEEN), + Arguments.of(NotEqualTo.class, true, Condition.EQUALS), + Arguments.of(NotIn.class, true, Condition.IN), + Arguments.of(NotLike.class, true, Condition.LIKE) + ); + } + interface PersonRepository extends BasicRepository { @Query("FROM Person WHERE name = :name") From 24d67e17196026dbc288a13b271cf2848a5b389e Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Fri, 27 Jun 2025 06:51:00 +0100 Subject: [PATCH 12/33] feat: make method factory at CriteriaCondition public Signed-off-by: Otavio Santana --- .../semistructured/CriteriaCondition.java | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) diff --git a/jnosql-communication/jnosql-communication-semistructured/src/main/java/org/eclipse/jnosql/communication/semistructured/CriteriaCondition.java b/jnosql-communication/jnosql-communication-semistructured/src/main/java/org/eclipse/jnosql/communication/semistructured/CriteriaCondition.java index 053dbacd9..d5ca66caa 100644 --- a/jnosql-communication/jnosql-communication-semistructured/src/main/java/org/eclipse/jnosql/communication/semistructured/CriteriaCondition.java +++ b/jnosql-communication/jnosql-communication-semistructured/src/main/java/org/eclipse/jnosql/communication/semistructured/CriteriaCondition.java @@ -169,7 +169,16 @@ public static CriteriaCondition readOnly(CriteriaCondition condition) { return new CriteriaCondition(condition.element(), condition.condition(), true); } - static CriteriaCondition of(Element element, Condition condition) { + + /** + * Creates a new {@link CriteriaCondition} with the specified element and condition. + * + * @param element the element representing the data to match + * @param condition the condition to apply + * @return a new {@link CriteriaCondition} + * @throws NullPointerException when the element or condition is null + */ + public static CriteriaCondition of(Element element, Condition condition) { return new CriteriaCondition(Objects.requireNonNull(element, "Column is required"), condition); } From 33a7ee8c1e87940905f55b46a3ccd2536b0875af Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Mon, 30 Jun 2025 08:14:41 +0100 Subject: [PATCH 13/33] feat: include semistructure parameter Signed-off-by: Otavio Santana --- .../AbstractSemiStructuredRepositoryProxy.java | 3 ++- .../SemiStructuredParameterBasedQuery.java | 17 +++++++++++------ 2 files changed, 13 insertions(+), 7 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/AbstractSemiStructuredRepositoryProxy.java b/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/AbstractSemiStructuredRepositoryProxy.java index 288d4ad0b..f83b81e08 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/AbstractSemiStructuredRepositoryProxy.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/AbstractSemiStructuredRepositoryProxy.java @@ -26,6 +26,7 @@ import org.eclipse.jnosql.communication.semistructured.QueryType; import org.eclipse.jnosql.mapping.core.repository.DynamicQueryMethodReturn; import org.eclipse.jnosql.mapping.core.repository.DynamicReturn; +import org.eclipse.jnosql.mapping.core.repository.ParamValue; import org.eclipse.jnosql.mapping.core.repository.RepositoryReflectionUtils; import org.eclipse.jnosql.mapping.metadata.EntityMetadata; import org.eclipse.jnosql.mapping.semistructured.MappingDeleteQuery; @@ -165,7 +166,7 @@ protected Object executeFindByQuery(Object instance, Method method, Object[] par @Override protected Object executeParameterBased(Object instance, Method method, Object[] params) { Class type = entityMetadata().type(); - Map parameters = RepositoryReflectionUtils.INSTANCE.getBy(method, params); + Map parameters = RepositoryReflectionUtils.INSTANCE.getBy(method, params); var query = SemiStructuredParameterBasedQuery.INSTANCE.toQuery(parameters, getSorts(method, entityMetadata()), entityMetadata()); return executeFindByQuery(method, params, type, updateQueryDynamically(params, query)); } diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java b/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java index 715345373..93c8fde5e 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java @@ -18,7 +18,9 @@ import jakarta.data.page.PageRequest; import jakarta.enterprise.inject.spi.CDI; import org.eclipse.jnosql.communication.semistructured.CriteriaCondition; +import org.eclipse.jnosql.communication.semistructured.Element; import org.eclipse.jnosql.mapping.core.NoSQLPage; +import org.eclipse.jnosql.mapping.core.repository.ParamValue; import org.eclipse.jnosql.mapping.semistructured.MappingQuery; import org.eclipse.jnosql.mapping.core.Converters; import org.eclipse.jnosql.mapping.metadata.EntityMetadata; @@ -49,12 +51,12 @@ public enum SemiStructuredParameterBasedQuery { * @param entityMetadata Metadata describing the structure of the entity. * @return A ColumnQuery instance tailored for the specified entity. */ - public org.eclipse.jnosql.communication.semistructured.SelectQuery toQuery(Map params, + public org.eclipse.jnosql.communication.semistructured.SelectQuery toQuery(Map params, List> sorts, EntityMetadata entityMetadata) { var convert = CDI.current().select(Converters.class).get(); List conditions = new ArrayList<>(); - for (Map.Entry entry : params.entrySet()) { + for (Map.Entry entry : params.entrySet()) { conditions.add(condition(convert, entityMetadata, entry)); } @@ -103,15 +105,18 @@ private CriteriaCondition condition(List conditions) { return CriteriaCondition.and(conditions.toArray(TO_ARRAY)); } - private CriteriaCondition condition(Converters convert, EntityMetadata entityMetadata, Map.Entry entry) { + private CriteriaCondition condition(Converters convert, EntityMetadata entityMetadata, Map.Entry entry) { var name = entityMetadata.fieldMapping(entry.getKey()) .map(FieldMetadata::name) .orElse(entry.getKey()); - var value = getValue(entry.getValue(), entityMetadata, entry.getKey(), convert); - return CriteriaCondition.eq(name, value); + var paramValue = entry.getValue(); + var condition = paramValue.condition(); + var value = getValue(paramValue, entityMetadata, entry.getKey(), convert); + var element = Element.of(name, value); + return CriteriaCondition.of(element, condition); } - private CriteriaCondition condition( EntityMetadata entityMetadata, Map.Entry entry) { + private CriteriaCondition condition(EntityMetadata entityMetadata, Map.Entry entry) { var name = entityMetadata.fieldMapping(entry.getKey()) .map(FieldMetadata::name) .orElse(entry.getKey()); From 9db5dc1c567bac2bd570504e74f958698f24df03 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Tue, 1 Jul 2025 20:32:38 +0100 Subject: [PATCH 14/33] feat: udpate condition structure Signed-off-by: Otavio Santana --- .../SemiStructuredParameterBasedQuery.java | 69 +++++++++++++------ 1 file changed, 48 insertions(+), 21 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java b/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java index 93c8fde5e..61d54e83b 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java @@ -17,6 +17,7 @@ import jakarta.data.Sort; import jakarta.data.page.PageRequest; import jakarta.enterprise.inject.spi.CDI; +import org.eclipse.jnosql.communication.Condition; import org.eclipse.jnosql.communication.semistructured.CriteriaCondition; import org.eclipse.jnosql.communication.semistructured.Element; import org.eclipse.jnosql.mapping.core.NoSQLPage; @@ -26,7 +27,9 @@ import org.eclipse.jnosql.mapping.metadata.EntityMetadata; import org.eclipse.jnosql.mapping.metadata.FieldMetadata; +import java.lang.reflect.Array; import java.util.ArrayList; +import java.util.Arrays; import java.util.List; import java.util.Map; import java.util.function.IntFunction; @@ -34,8 +37,8 @@ import static org.eclipse.jnosql.mapping.core.util.ConverterUtil.getValue; /** - * The ColumnParameterBasedQuery class is responsible for generating Column queries based on a set of parameters. - * It leverages the provided parameters, PageRequest information, and entity metadata to construct a ColumnQuery object + * The ColumnParameterBasedQuery class is responsible for generating Column queries based on a set of parameters. It + * leverages the provided parameters, PageRequest information, and entity metadata to construct a ColumnQuery object * tailored for querying a specific entity'sort columns. */ public enum SemiStructuredParameterBasedQuery { @@ -47,9 +50,9 @@ public enum SemiStructuredParameterBasedQuery { /** * Constructs a ColumnQuery based on the provided parameters, PageRequest information, and entity metadata. * - * @param params The map of parameters used for filtering columns. - * @param entityMetadata Metadata describing the structure of the entity. - * @return A ColumnQuery instance tailored for the specified entity. + * @param params The map of parameters used for filtering columns. + * @param entityMetadata Metadata describing the structure of the entity. + * @return A ColumnQuery instance tailored for the specified entity. */ public org.eclipse.jnosql.communication.semistructured.SelectQuery toQuery(Map params, List> sorts, @@ -68,16 +71,17 @@ public org.eclipse.jnosql.communication.semistructured.SelectQuery toQuery(Map params, - List> sorts, PageRequest pageRequest, - EntityMetadata entityMetadata) { + List> sorts, PageRequest pageRequest, + EntityMetadata entityMetadata) { List conditions = new ArrayList<>(); for (Map.Entry entry : params.entrySet()) { conditions.add(condition(entityMetadata, entry)); @@ -89,7 +93,7 @@ public org.eclipse.jnosql.communication.semistructured.SelectQuery toQueryNative var entity = entityMetadata.name(); long limit = 0; long skip = 0; - if(pageRequest != null) { + if (pageRequest != null) { limit = pageRequest.size(); skip = NoSQLPage.skip(pageRequest); } @@ -105,15 +109,38 @@ private CriteriaCondition condition(List conditions) { return CriteriaCondition.and(conditions.toArray(TO_ARRAY)); } - private CriteriaCondition condition(Converters convert, EntityMetadata entityMetadata, Map.Entry entry) { - var name = entityMetadata.fieldMapping(entry.getKey()) - .map(FieldMetadata::name) - .orElse(entry.getKey()); + private CriteriaCondition condition(Converters convert, EntityMetadata entityMetadata,Map.Entry entry) { + var fieldName = resolveFieldName(entityMetadata, entry.getKey()); var paramValue = entry.getValue(); var condition = paramValue.condition(); - var value = getValue(paramValue, entityMetadata, entry.getKey(), convert); - var element = Element.of(name, value); - return CriteriaCondition.of(element, condition); + Object value = extractConditionValue(paramValue.value(), condition, entityMetadata, entry.getKey(), convert); + return CriteriaCondition.of(Element.of(fieldName, value), condition); + } + + private String resolveFieldName(EntityMetadata metadata, String key) { + return metadata.fieldMapping(key).map(FieldMetadata::name).orElse(key); + } + + private Object extractConditionValue(Object rawValue, Condition condition, EntityMetadata metadata, + String fieldKey, Converters convert) { + if (Condition.BETWEEN.equals(condition) || Condition.IN.equals(condition)) { + return extractMultipleValues(rawValue, metadata, fieldKey, convert); + } + return getValue(rawValue, metadata, fieldKey, convert); + } + + private List extractMultipleValues(Object rawValue, EntityMetadata metadata, String fieldKey, + Converters convert) { + List values = new ArrayList<>(); + if (rawValue instanceof Iterable iterable) { + iterable.forEach(v -> values.add(getValue(v, metadata, fieldKey, convert))); + } else if (rawValue != null && rawValue.getClass().isArray()) { + for (int i = 0; i < Array.getLength(rawValue); i++) { + Object element = Array.get(rawValue, i); + values.add(getValue(element, metadata, fieldKey, convert)); + } + } + return values; } private CriteriaCondition condition(EntityMetadata entityMetadata, Map.Entry entry) { @@ -130,7 +157,7 @@ private List> getSorts(List> sorts, EntityMetadata entityMetadat var name = entityMetadata.fieldMapping(sort.property()) .map(FieldMetadata::name) .orElse(sort.property()); - updateSorter.add(sort.isAscending()? Sort.asc(name): Sort.desc(name)); + updateSorter.add(sort.isAscending() ? Sort.asc(name) : Sort.desc(name)); } return updateSorter; } From 4d072b76e4d11bb59cb87f4af7cb76aa4e6e7e44 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Tue, 1 Jul 2025 20:33:00 +0100 Subject: [PATCH 15/33] feat: update var on semistructure parameter based qusery Signed-off-by: Otavio Santana --- .../semistructured/query/SemiStructuredParameterBasedQuery.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java b/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java index 61d54e83b..6295f0b40 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java @@ -113,7 +113,7 @@ private CriteriaCondition condition(Converters convert, EntityMetadata entityMet var fieldName = resolveFieldName(entityMetadata, entry.getKey()); var paramValue = entry.getValue(); var condition = paramValue.condition(); - Object value = extractConditionValue(paramValue.value(), condition, entityMetadata, entry.getKey(), convert); + var value = extractConditionValue(paramValue.value(), condition, entityMetadata, entry.getKey(), convert); return CriteriaCondition.of(Element.of(fieldName, value), condition); } From 3608435f9f23062ec7ba791a630e7b5459073b5f Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Tue, 1 Jul 2025 20:33:34 +0100 Subject: [PATCH 16/33] style: remove unsed imports on SemiStructuredParameterBasedQuery Signed-off-by: Otavio Santana --- .../semistructured/query/SemiStructuredParameterBasedQuery.java | 1 - 1 file changed, 1 deletion(-) diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java b/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java index 6295f0b40..b3c814ac0 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java @@ -29,7 +29,6 @@ import java.lang.reflect.Array; import java.util.ArrayList; -import java.util.Arrays; import java.util.List; import java.util.Map; import java.util.function.IntFunction; From a412086fca870119000e01ef1f40bb1edac0385a Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Tue, 1 Jul 2025 20:36:08 +0100 Subject: [PATCH 17/33] test: update enable is annotation Signed-off-by: Otavio Santana --- .../query/SemiStructuredParameterBasedQueryTest.java | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java index e9e24550d..e69f7efa2 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java @@ -22,6 +22,7 @@ import org.eclipse.jnosql.communication.TypeReference; import org.eclipse.jnosql.communication.semistructured.CriteriaCondition; import org.eclipse.jnosql.communication.semistructured.Element; +import org.eclipse.jnosql.mapping.core.repository.ParamValue; import org.eclipse.jnosql.mapping.semistructured.EntityConverter; import org.eclipse.jnosql.mapping.semistructured.MockProducer; import org.eclipse.jnosql.mapping.semistructured.entities.Person; @@ -60,7 +61,7 @@ void setUp() { @Test void shouldCreateQuerySingleParameter() { - Map params = Map.of("name", "Ada"); + Map params = Map.of("name", new ParamValue(Condition.EQUALS, "Ada", false)); var query = SemiStructuredParameterBasedQuery.INSTANCE.toQuery(params, Collections.emptyList(), metadata); SoftAssertions.assertSoftly(soft -> { @@ -75,7 +76,8 @@ void shouldCreateQuerySingleParameter() { @Test void shouldCreateQueryMultipleParams() { - Map params = Map.of("name", "Ada", "age", 10); + Map params = Map.of("name", new ParamValue(Condition.EQUALS, "Ada", false), + "age", new ParamValue(Condition.EQUALS, 10, false)); var query = SemiStructuredParameterBasedQuery.INSTANCE.toQuery(params, Collections.emptyList(), metadata); SoftAssertions.assertSoftly(soft -> { @@ -95,7 +97,7 @@ void shouldCreateQueryMultipleParams() { @Test void shouldCreateQueryEmptyParams() { - Map params = Collections.emptyMap(); + Map params = Collections.emptyMap(); var query = SemiStructuredParameterBasedQuery.INSTANCE.toQuery(params, Collections.emptyList(), metadata); SoftAssertions.assertSoftly(soft -> { @@ -109,7 +111,7 @@ void shouldCreateQueryEmptyParams() { @Test void shouldAddSort() { - Map params = Collections.emptyMap(); + Map params = Collections.emptyMap(); var query = SemiStructuredParameterBasedQuery.INSTANCE.toQuery(params, List.of(Sort.asc("name")), metadata); SoftAssertions.assertSoftly(soft -> { From 0d5fe945a63d25b16996f39fbac9783744cc6ce8 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Wed, 2 Jul 2025 07:18:39 +0100 Subject: [PATCH 18/33] test: create negation condition Signed-off-by: Otavio Santana --- .../SemiStructuredParameterBasedQueryTest.java | 17 +++++++++++++++++ 1 file changed, 17 insertions(+) diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java index e69f7efa2..5f7a953e6 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java @@ -74,6 +74,23 @@ void shouldCreateQuerySingleParameter() { }); } + @Test + void shouldCreateQuerySingleParameterWithNot() { + Map params = Map.of("name", new ParamValue(Condition.EQUALS, "Ada", true)); + var query = SemiStructuredParameterBasedQuery.INSTANCE.toQuery(params, Collections.emptyList(), metadata); + + SoftAssertions.assertSoftly(soft -> { + soft.assertThat(query.limit()).isEqualTo(0L); + soft.assertThat(query.skip()).isEqualTo(0L); + soft.assertThat(query.name()).isEqualTo("Person"); + soft.assertThat(query.sorts()).isEmpty(); + soft.assertThat(query.condition()).isNotEmpty(); + var condition = query.condition().orElseThrow(); + soft.assertThat(condition.condition()).isEqualTo(Condition.NOT); + soft.assertThat(query.condition()).get().isEqualTo(CriteriaCondition.eq(Element.of("name", "Ada"))); + }); + } + @Test void shouldCreateQueryMultipleParams() { Map params = Map.of("name", new ParamValue(Condition.EQUALS, "Ada", false), From 6a50ab68b08eee71c870e001767eedd7a54c53bf Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Wed, 2 Jul 2025 07:26:33 +0100 Subject: [PATCH 19/33] feat: include negate condition Signed-off-by: Otavio Santana --- .../query/SemiStructuredParameterBasedQuery.java | 4 +++- .../query/SemiStructuredParameterBasedQueryTest.java | 3 ++- 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java b/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java index b3c814ac0..ed03cb1d1 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java @@ -113,7 +113,9 @@ private CriteriaCondition condition(Converters convert, EntityMetadata entityMet var paramValue = entry.getValue(); var condition = paramValue.condition(); var value = extractConditionValue(paramValue.value(), condition, entityMetadata, entry.getKey(), convert); - return CriteriaCondition.of(Element.of(fieldName, value), condition); + + return paramValue.negate() ? CriteriaCondition.of(Element.of(fieldName, value), condition).negate(): + CriteriaCondition.of(Element.of(fieldName, value), condition); } private String resolveFieldName(EntityMetadata metadata, String key) { diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java index 5f7a953e6..9ae5e5db3 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java @@ -87,7 +87,8 @@ void shouldCreateQuerySingleParameterWithNot() { soft.assertThat(query.condition()).isNotEmpty(); var condition = query.condition().orElseThrow(); soft.assertThat(condition.condition()).isEqualTo(Condition.NOT); - soft.assertThat(query.condition()).get().isEqualTo(CriteriaCondition.eq(Element.of("name", "Ada"))); + var criteriaCondition = condition.element().get(CriteriaCondition.class); + soft.assertThat(criteriaCondition).isEqualTo(CriteriaCondition.eq(Element.of("name", "Ada"))); }); } From 8372ee3051271daf3dd1c806e4aa9dffdcaee962 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Wed, 2 Jul 2025 07:31:33 +0100 Subject: [PATCH 20/33] test: update semistructured test paramter Signed-off-by: Otavio Santana --- ...SemiStructuredParameterBasedQueryTest.java | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java index 9ae5e5db3..857c0c05e 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java @@ -70,10 +70,29 @@ void shouldCreateQuerySingleParameter() { soft.assertThat(query.name()).isEqualTo("Person"); soft.assertThat(query.sorts()).isEmpty(); soft.assertThat(query.condition()).isNotEmpty(); + var condition = query.condition().orElseThrow(); + soft.assertThat(condition.condition()).isEqualTo(Condition.EQUALS); soft.assertThat(query.condition()).get().isEqualTo(CriteriaCondition.eq(Element.of("name", "Ada"))); }); } + @Test + void shouldCreateQueryGreaterThan() { + Map params = Map.of("name", new ParamValue(Condition.GREATER_THAN, "Ada", false)); + var query = SemiStructuredParameterBasedQuery.INSTANCE.toQuery(params, Collections.emptyList(), metadata); + + SoftAssertions.assertSoftly(soft -> { + soft.assertThat(query.limit()).isEqualTo(0L); + soft.assertThat(query.skip()).isEqualTo(0L); + soft.assertThat(query.name()).isEqualTo("Person"); + soft.assertThat(query.sorts()).isEmpty(); + soft.assertThat(query.condition()).isNotEmpty(); + var condition = query.condition().orElseThrow(); + soft.assertThat(condition.condition()).isEqualTo(Condition.GREATER_THAN); + soft.assertThat(condition.element()).isEqualTo(Element.of("name","Ada")); + }); + } + @Test void shouldCreateQuerySingleParameterWithNot() { Map params = Map.of("name", new ParamValue(Condition.EQUALS, "Ada", true)); From ef08c308a6c02012559cd2d7557596a9e8ca64e5 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Wed, 2 Jul 2025 07:37:08 +0100 Subject: [PATCH 21/33] test: include condition to simple query based Signed-off-by: Otavio Santana --- ...SemiStructuredParameterBasedQueryTest.java | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java index 857c0c05e..828d2ee23 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java @@ -36,6 +36,8 @@ import org.jboss.weld.junit5.auto.EnableAutoWeld; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; +import org.junit.jupiter.params.ParameterizedTest; +import org.junit.jupiter.params.provider.EnumSource; import java.util.Collections; import java.util.List; @@ -93,6 +95,24 @@ void shouldCreateQueryGreaterThan() { }); } + @ParameterizedTest(name = "Executing parameter query: {index} - {0}") + @EnumSource(value = Condition.class, names = {"IN", "BETWEEN", "OR", "AND", "NOT"}, mode = EnumSource.Mode.EXCLUDE) + void shouldUpdateParameterBasedOnQuery(Condition condition) { + Map params = Map.of("name", new ParamValue(condition,"Ada", false)); + var query = SemiStructuredParameterBasedQuery.INSTANCE.toQuery(params, Collections.emptyList(), metadata); + + SoftAssertions.assertSoftly(soft -> { + soft.assertThat(query.limit()).isEqualTo(0L); + soft.assertThat(query.skip()).isEqualTo(0L); + soft.assertThat(query.name()).isEqualTo("Person"); + soft.assertThat(query.sorts()).isEmpty(); + soft.assertThat(query.condition()).isNotEmpty(); + var criteriaCondition = query.condition().orElseThrow(); + soft.assertThat(criteriaCondition.condition()).isEqualTo(condition); + soft.assertThat(criteriaCondition.element()).isEqualTo(Element.of("name", "Ada")); + }); + } + @Test void shouldCreateQuerySingleParameterWithNot() { Map params = Map.of("name", new ParamValue(Condition.EQUALS, "Ada", true)); From 3add6a3bfbc5980cc2c6fcea8290b6cf7ca2b0ff Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Wed, 2 Jul 2025 07:42:04 +0100 Subject: [PATCH 22/33] test: update test scenario to work with In and between Signed-off-by: Otavio Santana --- ...SemiStructuredParameterBasedQueryTest.java | 38 ++++++++++++++++++- 1 file changed, 37 insertions(+), 1 deletion(-) diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java index 828d2ee23..068f7cb34 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java @@ -97,7 +97,7 @@ void shouldCreateQueryGreaterThan() { @ParameterizedTest(name = "Executing parameter query: {index} - {0}") @EnumSource(value = Condition.class, names = {"IN", "BETWEEN", "OR", "AND", "NOT"}, mode = EnumSource.Mode.EXCLUDE) - void shouldUpdateParameterBasedOnQuery(Condition condition) { + void shouldUpdateParameterBasedOnSimpleQuery(Condition condition) { Map params = Map.of("name", new ParamValue(condition,"Ada", false)); var query = SemiStructuredParameterBasedQuery.INSTANCE.toQuery(params, Collections.emptyList(), metadata); @@ -113,6 +113,42 @@ void shouldUpdateParameterBasedOnQuery(Condition condition) { }); } + @ParameterizedTest(name = "Executing parameter query: {index} - {0}") + @EnumSource(value = Condition.class, names = {"IN", "BETWEEN"}, mode = EnumSource.Mode.INCLUDE) + void shouldUpdateParameterBasedOnQueryThatNeedsIterable(Condition condition) { + Map params = Map.of("age", new ParamValue(condition, List.of(10, 20), false)); + var query = SemiStructuredParameterBasedQuery.INSTANCE.toQuery(params, Collections.emptyList(), metadata); + + SoftAssertions.assertSoftly(soft -> { + soft.assertThat(query.limit()).isEqualTo(0L); + soft.assertThat(query.skip()).isEqualTo(0L); + soft.assertThat(query.name()).isEqualTo("Person"); + soft.assertThat(query.sorts()).isEmpty(); + soft.assertThat(query.condition()).isNotEmpty(); + var criteriaCondition = query.condition().orElseThrow(); + soft.assertThat(criteriaCondition.condition()).isEqualTo(condition); + soft.assertThat(criteriaCondition.element()).isEqualTo(Element.of("age", List.of(10, 20))); + }); + } + + @ParameterizedTest(name = "Executing parameter query: {index} - {0}") + @EnumSource(value = Condition.class, names = {"IN", "BETWEEN"}, mode = EnumSource.Mode.INCLUDE) + void shouldUpdateParameterBasedOnQueryThatNeedsArray(Condition condition) { + Map params = Map.of("age", new ParamValue(condition, new int[]{10, 20}, false)); + var query = SemiStructuredParameterBasedQuery.INSTANCE.toQuery(params, Collections.emptyList(), metadata); + + SoftAssertions.assertSoftly(soft -> { + soft.assertThat(query.limit()).isEqualTo(0L); + soft.assertThat(query.skip()).isEqualTo(0L); + soft.assertThat(query.name()).isEqualTo("Person"); + soft.assertThat(query.sorts()).isEmpty(); + soft.assertThat(query.condition()).isNotEmpty(); + var criteriaCondition = query.condition().orElseThrow(); + soft.assertThat(criteriaCondition.condition()).isEqualTo(condition); + soft.assertThat(criteriaCondition.element()).isEqualTo(Element.of("age", List.of(10, 20))); + }); + } + @Test void shouldCreateQuerySingleParameterWithNot() { Map params = Map.of("name", new ParamValue(Condition.EQUALS, "Ada", true)); From 3b14d0cf58ef47a6ba8c68ddeaf94a685d774db0 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Wed, 2 Jul 2025 07:52:49 +0100 Subject: [PATCH 23/33] feat: include validation to simple query Signed-off-by: Otavio Santana --- .../SemiStructuredParameterBasedQuery.java | 4 ++++ .../SemiStructuredParameterBasedQueryTest.java | 17 +++++++++++++++++ 2 files changed, 21 insertions(+) diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java b/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java index ed03cb1d1..d166272f1 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java @@ -29,6 +29,7 @@ import java.lang.reflect.Array; import java.util.ArrayList; +import java.util.Collection; import java.util.List; import java.util.Map; import java.util.function.IntFunction; @@ -127,6 +128,9 @@ private Object extractConditionValue(Object rawValue, Condition condition, Entit if (Condition.BETWEEN.equals(condition) || Condition.IN.equals(condition)) { return extractMultipleValues(rawValue, metadata, fieldKey, convert); } + if(rawValue instanceof Iterable || rawValue != null && rawValue.getClass().isArray()) { + throw new IllegalArgumentException("The value for condition " + condition + " must be a single value, but received: " + rawValue); + } return getValue(rawValue, metadata, fieldKey, convert); } diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java index 068f7cb34..d8e5af829 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java @@ -17,6 +17,7 @@ import jakarta.data.Sort; import jakarta.data.page.PageRequest; import jakarta.inject.Inject; +import org.assertj.core.api.Assertions; import org.assertj.core.api.SoftAssertions; import org.eclipse.jnosql.communication.Condition; import org.eclipse.jnosql.communication.TypeReference; @@ -113,6 +114,22 @@ void shouldUpdateParameterBasedOnSimpleQuery(Condition condition) { }); } + @ParameterizedTest(name = "Executing invalid iterable to parameter query: {index} - {0}") + @EnumSource(value = Condition.class, names = {"IN", "BETWEEN", "OR", "AND", "NOT"}, mode = EnumSource.Mode.EXCLUDE) + void shouldNotAllowIterableOnSimpleQuery(Condition condition) { + Map params = Map.of("name", new ParamValue(condition,List.of("Ada"), false)); + Assertions.assertThatThrownBy(() -> SemiStructuredParameterBasedQuery.INSTANCE.toQuery(params, Collections.emptyList(), metadata)) + .isInstanceOf(IllegalArgumentException.class); + } + + @ParameterizedTest(name = "Executing invalid array to parameter query: {index} - {0}") + @EnumSource(value = Condition.class, names = {"IN", "BETWEEN", "OR", "AND", "NOT"}, mode = EnumSource.Mode.EXCLUDE) + void shouldNotAllowArrayOnSimpleQuery(Condition condition) { + Map params = Map.of("name", new ParamValue(condition, new String[] {"Ada"}, false)); + Assertions.assertThatThrownBy(() -> SemiStructuredParameterBasedQuery.INSTANCE.toQuery(params, Collections.emptyList(), metadata)) + .isInstanceOf(IllegalArgumentException.class); + } + @ParameterizedTest(name = "Executing parameter query: {index} - {0}") @EnumSource(value = Condition.class, names = {"IN", "BETWEEN"}, mode = EnumSource.Mode.INCLUDE) void shouldUpdateParameterBasedOnQueryThatNeedsIterable(Condition condition) { From 80d0513ab80d0b5c54bf467cd031c50cdb45b9f3 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Wed, 2 Jul 2025 07:54:01 +0100 Subject: [PATCH 24/33] feat: include validation to iterable Signed-off-by: Otavio Santana --- .../query/SemiStructuredParameterBasedQuery.java | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java b/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java index d166272f1..be7146b10 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java @@ -125,10 +125,15 @@ private String resolveFieldName(EntityMetadata metadata, String key) { private Object extractConditionValue(Object rawValue, Condition condition, EntityMetadata metadata, String fieldKey, Converters convert) { + boolean isCollectionParameter = rawValue instanceof Iterable || rawValue != null && rawValue.getClass().isArray(); + if (Condition.BETWEEN.equals(condition) || Condition.IN.equals(condition)) { + if (!isCollectionParameter) { + throw new IllegalArgumentException("The value for condition " + condition + " must be a Iterable or array, but received: " + rawValue); + } return extractMultipleValues(rawValue, metadata, fieldKey, convert); } - if(rawValue instanceof Iterable || rawValue != null && rawValue.getClass().isArray()) { + if(isCollectionParameter) { throw new IllegalArgumentException("The value for condition " + condition + " must be a single value, but received: " + rawValue); } return getValue(rawValue, metadata, fieldKey, convert); From 5dfa31448bd82944a1ba14469a7c53b1f6906b04 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Wed, 2 Jul 2025 07:55:23 +0100 Subject: [PATCH 25/33] test: generate scenarion to not allow arrray and iterable Signed-off-by: Otavio Santana --- .../query/SemiStructuredParameterBasedQueryTest.java | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java index d8e5af829..2baae7d2b 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java @@ -130,6 +130,14 @@ void shouldNotAllowArrayOnSimpleQuery(Condition condition) { .isInstanceOf(IllegalArgumentException.class); } + @ParameterizedTest(name = "Executing invalid iterable to parameter query: {index} - {0}") + @EnumSource(value = Condition.class, names = {"IN", "BETWEEN"}, mode = EnumSource.Mode.INCLUDE) + void shouldNotAllowNotArrayAndIterable(Condition condition) { + Map params = Map.of("name", new ParamValue(condition,"Ada", false)); + Assertions.assertThatThrownBy(() -> SemiStructuredParameterBasedQuery.INSTANCE.toQuery(params, Collections.emptyList(), metadata)) + .isInstanceOf(IllegalArgumentException.class); + } + @ParameterizedTest(name = "Executing parameter query: {index} - {0}") @EnumSource(value = Condition.class, names = {"IN", "BETWEEN"}, mode = EnumSource.Mode.INCLUDE) void shouldUpdateParameterBasedOnQueryThatNeedsIterable(Condition condition) { From f62876f7c544d6e19945d63912b41b29b799971d Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Wed, 2 Jul 2025 08:08:59 +0100 Subject: [PATCH 26/33] feat: include validation to between Signed-off-by: Otavio Santana --- .../query/SemiStructuredParameterBasedQuery.java | 7 +++++-- .../query/SemiStructuredParameterBasedQueryTest.java | 7 +++++++ 2 files changed, 12 insertions(+), 2 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java b/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java index be7146b10..d4814d684 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java @@ -131,7 +131,7 @@ private Object extractConditionValue(Object rawValue, Condition condition, Entit if (!isCollectionParameter) { throw new IllegalArgumentException("The value for condition " + condition + " must be a Iterable or array, but received: " + rawValue); } - return extractMultipleValues(rawValue, metadata, fieldKey, convert); + return extractMultipleValues(rawValue, metadata, fieldKey, convert, condition); } if(isCollectionParameter) { throw new IllegalArgumentException("The value for condition " + condition + " must be a single value, but received: " + rawValue); @@ -140,7 +140,7 @@ private Object extractConditionValue(Object rawValue, Condition condition, Entit } private List extractMultipleValues(Object rawValue, EntityMetadata metadata, String fieldKey, - Converters convert) { + Converters convert, Condition condition) { List values = new ArrayList<>(); if (rawValue instanceof Iterable iterable) { iterable.forEach(v -> values.add(getValue(v, metadata, fieldKey, convert))); @@ -150,6 +150,9 @@ private List extractMultipleValues(Object rawValue, EntityMetadata metad values.add(getValue(element, metadata, fieldKey, convert)); } } + if (Condition.BETWEEN.equals(condition) && values.size() != 2) { + throw new IllegalArgumentException("The value for condition " + condition + " must have exactly two elements, but received: " + values); + } return values; } diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java index 2baae7d2b..99e21ec3d 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java @@ -156,6 +156,13 @@ void shouldUpdateParameterBasedOnQueryThatNeedsIterable(Condition condition) { }); } + @Test + void shouldNotAllowBetweenWithSingleValue() { + Map params = Map.of("age", new ParamValue(Condition.BETWEEN, List.of(10), false)); + Assertions.assertThatThrownBy(() -> SemiStructuredParameterBasedQuery.INSTANCE.toQuery(params, Collections.emptyList(), metadata)) + .isInstanceOf(IllegalArgumentException.class); + } + @ParameterizedTest(name = "Executing parameter query: {index} - {0}") @EnumSource(value = Condition.class, names = {"IN", "BETWEEN"}, mode = EnumSource.Mode.INCLUDE) void shouldUpdateParameterBasedOnQueryThatNeedsArray(Condition condition) { From 357f9a9e27c4760a6013f4391ff4cbbc0cadd2b2 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Wed, 2 Jul 2025 08:09:26 +0100 Subject: [PATCH 27/33] style: remove imports no structure on parameter query Signed-off-by: Otavio Santana --- .../semistructured/query/SemiStructuredParameterBasedQuery.java | 1 - 1 file changed, 1 deletion(-) diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java b/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java index d4814d684..8b9023936 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQuery.java @@ -29,7 +29,6 @@ import java.lang.reflect.Array; import java.util.ArrayList; -import java.util.Collection; import java.util.List; import java.util.Map; import java.util.function.IntFunction; From 53877b815b0946dfb4a91f95c65a11e844470bbf Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Wed, 2 Jul 2025 20:55:45 +0100 Subject: [PATCH 28/33] style: remove unsed imports Signed-off-by: Otavio Santana --- .../semistructured/DatabaseQualifierTest.java | 5 ++- .../DefaultSemiStructuredTemplateTest.java | 19 ++++++---- .../EntityConverterConstructorTest.java | 4 +-- .../EntityConverterInheritanceTest.java | 4 +-- .../semistructured/EntityConverterTest.java | 4 +-- .../semistructured/EntityImmutableTest.java | 10 +++--- .../semistructured/MapperDeleteTest.java | 6 ++-- .../semistructured/MapperObserverTest.java | 6 ++-- .../semistructured/MapperSelectTest.java | 6 ++-- .../semistructured/PreparedStatementTest.java | 2 +- .../ProjectorConverterTest.java | 2 -- .../semistructured/SelectFieldMapperTest.java | 4 +-- .../TemplateInheritanceTest.java | 6 ++-- .../semistructured/entities/Worker.java | 2 +- .../entities/constructor/Computer.java | 2 +- .../inheritance/EmailNotification.java | 2 +- .../entities/inheritance/LargeProject.java | 2 +- .../entities/inheritance/Project.java | 2 +- .../entities/inheritance/SmallProject.java | 2 +- .../entities/inheritance/SmsNotification.java | 2 +- .../query/BaseRepositoryBeanTest.java | 9 +++-- .../CrudInheritanceRepositoryProxyTest.java | 10 +++--- .../query/CrudRepositoryProxyIsTest.java | 14 -------- .../CrudRepositoryProxyRestrictionTest.java | 29 --------------- .../query/CrudRepositoryProxyTest.java | 36 ++++++++++++------- ...ustomRepositoryHandlerRestrictionTest.java | 9 ----- .../query/CustomRepositoryHandlerTest.java | 2 +- .../query/DynamicQueryTest.java | 2 +- .../query/ParamsBinderTest.java | 8 ++--- .../query/RepositoryBeanTest.java | 8 +++-- .../query/RepositoryProxyPageRequestTest.java | 25 +++++++++---- .../query/RepositoryProxyTest.java | 35 ++++++++++++------ ...itorySemiStructuredObserverParserTest.java | 5 +-- ...SemiStructuredParameterBasedQueryTest.java | 10 +++--- 34 files changed, 147 insertions(+), 147 deletions(-) diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/DatabaseQualifierTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/DatabaseQualifierTest.java index e9230bdb9..3c5cb36fd 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/DatabaseQualifierTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/DatabaseQualifierTest.java @@ -18,7 +18,10 @@ import org.junit.jupiter.api.Assertions; import org.junit.jupiter.api.Test; -import static org.eclipse.jnosql.mapping.DatabaseType.*; +import static org.eclipse.jnosql.mapping.DatabaseType.COLUMN; +import static org.eclipse.jnosql.mapping.DatabaseType.DOCUMENT; +import static org.eclipse.jnosql.mapping.DatabaseType.GRAPH; +import static org.eclipse.jnosql.mapping.DatabaseType.KEY_VALUE; import static org.junit.jupiter.api.Assertions.assertEquals; class DatabaseQualifierTest { diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/DefaultSemiStructuredTemplateTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/DefaultSemiStructuredTemplateTest.java index 4ab05dede..8417724b1 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/DefaultSemiStructuredTemplateTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/DefaultSemiStructuredTemplateTest.java @@ -21,22 +21,22 @@ import jakarta.data.page.impl.CursoredPageRecord; import jakarta.enterprise.inject.Instance; import jakarta.inject.Inject; -import org.eclipse.jnosql.communication.Configurations; -import org.eclipse.jnosql.mapping.PreparedStatement; import org.assertj.core.api.SoftAssertions; +import org.eclipse.jnosql.communication.Configurations; import org.eclipse.jnosql.communication.semistructured.CommunicationEntity; import org.eclipse.jnosql.communication.semistructured.CriteriaCondition; import org.eclipse.jnosql.communication.semistructured.DatabaseManager; import org.eclipse.jnosql.communication.semistructured.DeleteQuery; import org.eclipse.jnosql.communication.semistructured.Element; import org.eclipse.jnosql.communication.semistructured.SelectQuery; -import org.eclipse.jnosql.mapping.core.Converters; import org.eclipse.jnosql.mapping.IdNotFoundException; -import org.eclipse.jnosql.mapping.semistructured.entities.Job; -import org.eclipse.jnosql.mapping.semistructured.entities.Person; +import org.eclipse.jnosql.mapping.PreparedStatement; +import org.eclipse.jnosql.mapping.core.Converters; import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata; import org.eclipse.jnosql.mapping.reflection.Reflections; import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; +import org.eclipse.jnosql.mapping.semistructured.entities.Job; +import org.eclipse.jnosql.mapping.semistructured.entities.Person; import org.jboss.weld.junit5.auto.AddExtensions; import org.jboss.weld.junit5.auto.AddPackages; import org.jboss.weld.junit5.auto.EnableAutoWeld; @@ -56,9 +56,14 @@ import static org.eclipse.jnosql.communication.semistructured.DeleteQuery.delete; import static org.eclipse.jnosql.communication.semistructured.SelectQuery.select; -import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; -import static org.mockito.Mockito.*; +import static org.mockito.Mockito.never; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; @EnableAutoWeld @AddPackages(value = {Converters.class, EntityConverter.class}) diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/EntityConverterConstructorTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/EntityConverterConstructorTest.java index 93b2ea32d..d5e9fd1e4 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/EntityConverterConstructorTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/EntityConverterConstructorTest.java @@ -20,14 +20,12 @@ import org.eclipse.jnosql.communication.semistructured.CommunicationEntity; import org.eclipse.jnosql.communication.semistructured.Element; import org.eclipse.jnosql.mapping.core.Converters; -import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; import org.eclipse.jnosql.mapping.reflection.Reflections; +import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; import org.eclipse.jnosql.mapping.semistructured.entities.Animal; import org.eclipse.jnosql.mapping.semistructured.entities.Book; import org.eclipse.jnosql.mapping.semistructured.entities.BookRelease; -import org.eclipse.jnosql.mapping.semistructured.entities.MobileApp; import org.eclipse.jnosql.mapping.semistructured.entities.Money; -import org.eclipse.jnosql.mapping.semistructured.entities.Program; import org.eclipse.jnosql.mapping.semistructured.entities.constructor.Beer; import org.eclipse.jnosql.mapping.semistructured.entities.constructor.BeerFactory; import org.eclipse.jnosql.mapping.semistructured.entities.constructor.BookBag; diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/EntityConverterInheritanceTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/EntityConverterInheritanceTest.java index 5967c1037..c9f050aac 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/EntityConverterInheritanceTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/EntityConverterInheritanceTest.java @@ -20,6 +20,8 @@ import org.eclipse.jnosql.communication.semistructured.CommunicationEntity; import org.eclipse.jnosql.communication.semistructured.Element; import org.eclipse.jnosql.mapping.core.Converters; +import org.eclipse.jnosql.mapping.reflection.Reflections; +import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; import org.eclipse.jnosql.mapping.semistructured.entities.inheritance.EmailNotification; import org.eclipse.jnosql.mapping.semistructured.entities.inheritance.LargeProject; import org.eclipse.jnosql.mapping.semistructured.entities.inheritance.Notification; @@ -29,8 +31,6 @@ import org.eclipse.jnosql.mapping.semistructured.entities.inheritance.SmallProject; import org.eclipse.jnosql.mapping.semistructured.entities.inheritance.SmsNotification; import org.eclipse.jnosql.mapping.semistructured.entities.inheritance.SocialMediaNotification; -import org.eclipse.jnosql.mapping.reflection.Reflections; -import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; import org.jboss.weld.junit5.auto.AddExtensions; import org.jboss.weld.junit5.auto.AddPackages; import org.jboss.weld.junit5.auto.EnableAutoWeld; diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/EntityConverterTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/EntityConverterTest.java index 57a0d77c9..16eb4341a 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/EntityConverterTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/EntityConverterTest.java @@ -21,14 +21,13 @@ import org.eclipse.jnosql.communication.semistructured.CommunicationEntity; import org.eclipse.jnosql.communication.semistructured.Element; import org.eclipse.jnosql.mapping.core.Converters; -import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; import org.eclipse.jnosql.mapping.reflection.Reflections; +import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; import org.eclipse.jnosql.mapping.semistructured.entities.Actor; import org.eclipse.jnosql.mapping.semistructured.entities.Address; import org.eclipse.jnosql.mapping.semistructured.entities.AppointmentBook; import org.eclipse.jnosql.mapping.semistructured.entities.Book; import org.eclipse.jnosql.mapping.semistructured.entities.Citizen; -import org.eclipse.jnosql.mapping.semistructured.entities.MobileApp; import org.eclipse.jnosql.mapping.semistructured.entities.Contact; import org.eclipse.jnosql.mapping.semistructured.entities.ContactType; import org.eclipse.jnosql.mapping.semistructured.entities.Director; @@ -39,6 +38,7 @@ import org.eclipse.jnosql.mapping.semistructured.entities.Job; import org.eclipse.jnosql.mapping.semistructured.entities.Machine; import org.eclipse.jnosql.mapping.semistructured.entities.MainStepType; +import org.eclipse.jnosql.mapping.semistructured.entities.MobileApp; import org.eclipse.jnosql.mapping.semistructured.entities.Money; import org.eclipse.jnosql.mapping.semistructured.entities.Movie; import org.eclipse.jnosql.mapping.semistructured.entities.Person; diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/EntityImmutableTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/EntityImmutableTest.java index 2694fdd70..7092d8351 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/EntityImmutableTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/EntityImmutableTest.java @@ -19,11 +19,11 @@ import org.eclipse.jnosql.communication.semistructured.CommunicationEntity; import org.eclipse.jnosql.communication.semistructured.Element; import org.eclipse.jnosql.mapping.core.Converters; +import org.eclipse.jnosql.mapping.reflection.Reflections; +import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; import org.eclipse.jnosql.mapping.semistructured.entities.Car; import org.eclipse.jnosql.mapping.semistructured.entities.Failure; import org.eclipse.jnosql.mapping.semistructured.entities.Hero; -import org.eclipse.jnosql.mapping.reflection.Reflections; -import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; import org.jboss.weld.junit5.auto.AddExtensions; import org.jboss.weld.junit5.auto.AddPackages; import org.jboss.weld.junit5.auto.EnableAutoWeld; @@ -31,12 +31,14 @@ import org.junit.jupiter.api.Test; import java.time.Year; -import java.util.Arrays; import java.util.stream.Stream; import static org.assertj.core.api.Assertions.assertThat; import static org.assertj.core.api.SoftAssertions.assertSoftly; -import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertSame; @EnableAutoWeld @AddPackages(value = {Converters.class, EntityConverter.class}) diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/MapperDeleteTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/MapperDeleteTest.java index b1b7a1a6d..f70ef4a46 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/MapperDeleteTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/MapperDeleteTest.java @@ -19,13 +19,13 @@ import org.eclipse.jnosql.communication.semistructured.DatabaseManager; import org.eclipse.jnosql.communication.semistructured.DeleteQuery; import org.eclipse.jnosql.mapping.core.Converters; +import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata; +import org.eclipse.jnosql.mapping.reflection.Reflections; +import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; import org.eclipse.jnosql.mapping.semistructured.entities.Address; import org.eclipse.jnosql.mapping.semistructured.entities.Money; import org.eclipse.jnosql.mapping.semistructured.entities.Person; import org.eclipse.jnosql.mapping.semistructured.entities.Worker; -import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata; -import org.eclipse.jnosql.mapping.reflection.Reflections; -import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; import org.jboss.weld.junit5.auto.AddExtensions; import org.jboss.weld.junit5.auto.AddPackages; import org.jboss.weld.junit5.auto.EnableAutoWeld; diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/MapperObserverTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/MapperObserverTest.java index ac86fd7fe..bd43f0e63 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/MapperObserverTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/MapperObserverTest.java @@ -17,12 +17,12 @@ import jakarta.inject.Inject; import org.eclipse.jnosql.communication.semistructured.CommunicationObserverParser; import org.eclipse.jnosql.mapping.core.Converters; -import org.eclipse.jnosql.mapping.semistructured.entities.Car; -import org.eclipse.jnosql.mapping.semistructured.entities.Vendor; -import org.eclipse.jnosql.mapping.semistructured.entities.Worker; import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata; import org.eclipse.jnosql.mapping.reflection.Reflections; import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; +import org.eclipse.jnosql.mapping.semistructured.entities.Car; +import org.eclipse.jnosql.mapping.semistructured.entities.Vendor; +import org.eclipse.jnosql.mapping.semistructured.entities.Worker; import org.jboss.weld.junit5.auto.AddExtensions; import org.jboss.weld.junit5.auto.AddPackages; import org.jboss.weld.junit5.auto.EnableAutoWeld; diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/MapperSelectTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/MapperSelectTest.java index 5d5501f75..e14f03dad 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/MapperSelectTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/MapperSelectTest.java @@ -20,13 +20,13 @@ import org.eclipse.jnosql.communication.semistructured.DatabaseManager; import org.eclipse.jnosql.communication.semistructured.SelectQuery; import org.eclipse.jnosql.mapping.core.Converters; +import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata; +import org.eclipse.jnosql.mapping.reflection.Reflections; +import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; import org.eclipse.jnosql.mapping.semistructured.entities.Address; import org.eclipse.jnosql.mapping.semistructured.entities.Money; import org.eclipse.jnosql.mapping.semistructured.entities.Person; import org.eclipse.jnosql.mapping.semistructured.entities.Worker; -import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata; -import org.eclipse.jnosql.mapping.reflection.Reflections; -import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; import org.jboss.weld.junit5.auto.AddExtensions; import org.jboss.weld.junit5.auto.AddPackages; import org.jboss.weld.junit5.auto.EnableAutoWeld; diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/PreparedStatementTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/PreparedStatementTest.java index 7c7ec416c..351fea0c6 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/PreparedStatementTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/PreparedStatementTest.java @@ -19,9 +19,9 @@ import org.eclipse.jnosql.communication.semistructured.CommunicationEntity; import org.eclipse.jnosql.communication.semistructured.SelectQuery; import org.eclipse.jnosql.mapping.core.Converters; -import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata; import org.eclipse.jnosql.mapping.reflection.Reflections; +import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; import org.eclipse.jnosql.mapping.semistructured.entities.Person; import org.jboss.weld.junit5.auto.AddExtensions; import org.jboss.weld.junit5.auto.AddPackages; diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/ProjectorConverterTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/ProjectorConverterTest.java index 985b61af7..4e681d955 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/ProjectorConverterTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/ProjectorConverterTest.java @@ -30,8 +30,6 @@ import org.jboss.weld.junit5.auto.EnableAutoWeld; import org.junit.jupiter.api.Test; -import java.util.Optional; - @EnableAutoWeld @AddPackages(value = {Converters.class, EntityConverter.class}) diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/SelectFieldMapperTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/SelectFieldMapperTest.java index 18d10d7c7..d452ff147 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/SelectFieldMapperTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/SelectFieldMapperTest.java @@ -22,9 +22,9 @@ import org.eclipse.jnosql.communication.semistructured.Element; import org.eclipse.jnosql.communication.semistructured.SelectQuery; import org.eclipse.jnosql.mapping.core.Converters; -import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata; import org.eclipse.jnosql.mapping.reflection.Reflections; +import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; import org.eclipse.jnosql.mapping.semistructured.entities.Person; import org.jboss.weld.junit5.auto.AddExtensions; import org.jboss.weld.junit5.auto.AddPackages; @@ -38,7 +38,7 @@ import java.util.List; import java.util.stream.Stream; -import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.api.Assertions.assertEquals; @EnableAutoWeld @AddPackages(value = {Converters.class, EntityConverter.class}) diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/TemplateInheritanceTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/TemplateInheritanceTest.java index 9c91bc477..f4126fc33 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/TemplateInheritanceTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/TemplateInheritanceTest.java @@ -23,12 +23,12 @@ import org.eclipse.jnosql.communication.semistructured.DeleteQuery; import org.eclipse.jnosql.communication.semistructured.Element; import org.eclipse.jnosql.communication.semistructured.SelectQuery; -import org.eclipse.jnosql.mapping.semistructured.entities.inheritance.EmailNotification; -import org.eclipse.jnosql.mapping.semistructured.entities.inheritance.Notification; import org.eclipse.jnosql.mapping.core.Converters; -import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata; import org.eclipse.jnosql.mapping.reflection.Reflections; +import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; +import org.eclipse.jnosql.mapping.semistructured.entities.inheritance.EmailNotification; +import org.eclipse.jnosql.mapping.semistructured.entities.inheritance.Notification; import org.jboss.weld.junit5.auto.AddExtensions; import org.jboss.weld.junit5.auto.AddPackages; import org.jboss.weld.junit5.auto.EnableAutoWeld; diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/entities/Worker.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/entities/Worker.java index 89a5c30df..986bad534 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/entities/Worker.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/entities/Worker.java @@ -16,8 +16,8 @@ import jakarta.nosql.Column; -import jakarta.nosql.Entity; import jakarta.nosql.Convert; +import jakarta.nosql.Entity; @Entity public class Worker { diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/entities/constructor/Computer.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/entities/constructor/Computer.java index 55879c8d6..f8f444cf2 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/entities/constructor/Computer.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/entities/constructor/Computer.java @@ -15,9 +15,9 @@ package org.eclipse.jnosql.mapping.semistructured.entities.constructor; import jakarta.nosql.Column; +import jakarta.nosql.Convert; import jakarta.nosql.Entity; import jakarta.nosql.Id; -import jakarta.nosql.Convert; import org.eclipse.jnosql.mapping.semistructured.entities.Money; import org.eclipse.jnosql.mapping.semistructured.entities.MoneyConverter; diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/entities/inheritance/EmailNotification.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/entities/inheritance/EmailNotification.java index 48171bfbd..8f84c146d 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/entities/inheritance/EmailNotification.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/entities/inheritance/EmailNotification.java @@ -16,8 +16,8 @@ package org.eclipse.jnosql.mapping.semistructured.entities.inheritance; import jakarta.nosql.Column; -import jakarta.nosql.Entity; import jakarta.nosql.DiscriminatorValue; +import jakarta.nosql.Entity; @Entity @DiscriminatorValue("Email") diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/entities/inheritance/LargeProject.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/entities/inheritance/LargeProject.java index 7c701798e..19f86c292 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/entities/inheritance/LargeProject.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/entities/inheritance/LargeProject.java @@ -16,8 +16,8 @@ package org.eclipse.jnosql.mapping.semistructured.entities.inheritance; import jakarta.nosql.Column; -import jakarta.nosql.Entity; import jakarta.nosql.DiscriminatorValue; +import jakarta.nosql.Entity; import java.math.BigDecimal; diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/entities/inheritance/Project.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/entities/inheritance/Project.java index 9cbc11df6..8436c3510 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/entities/inheritance/Project.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/entities/inheritance/Project.java @@ -15,9 +15,9 @@ package org.eclipse.jnosql.mapping.semistructured.entities.inheritance; +import jakarta.nosql.DiscriminatorColumn; import jakarta.nosql.Entity; import jakarta.nosql.Id; -import jakarta.nosql.DiscriminatorColumn; import jakarta.nosql.Inheritance; import java.util.Objects; diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/entities/inheritance/SmallProject.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/entities/inheritance/SmallProject.java index d087a94b9..5f392e8c6 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/entities/inheritance/SmallProject.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/entities/inheritance/SmallProject.java @@ -16,8 +16,8 @@ package org.eclipse.jnosql.mapping.semistructured.entities.inheritance; import jakarta.nosql.Column; -import jakarta.nosql.Entity; import jakarta.nosql.DiscriminatorValue; +import jakarta.nosql.Entity; @Entity @DiscriminatorValue("Small") diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/entities/inheritance/SmsNotification.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/entities/inheritance/SmsNotification.java index 1997e81d4..27f60aba9 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/entities/inheritance/SmsNotification.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/entities/inheritance/SmsNotification.java @@ -16,8 +16,8 @@ package org.eclipse.jnosql.mapping.semistructured.entities.inheritance; import jakarta.nosql.Column; -import jakarta.nosql.Entity; import jakarta.nosql.DiscriminatorValue; +import jakarta.nosql.Entity; @Entity @DiscriminatorValue("SMS") diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/BaseRepositoryBeanTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/BaseRepositoryBeanTest.java index 48150d1b0..3ceb692bd 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/BaseRepositoryBeanTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/BaseRepositoryBeanTest.java @@ -22,15 +22,20 @@ import org.eclipse.jnosql.mapping.semistructured.SemiStructuredTemplate; import org.junit.jupiter.api.BeforeEach; import org.junit.jupiter.api.Test; + +import java.lang.annotation.Annotation; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Proxy; -import java.lang.annotation.Annotation; import java.lang.reflect.Type; import java.util.Set; import static org.assertj.core.api.Assertions.assertThat; import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.mockito.Mockito.*; +import static org.mockito.Mockito.any; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.spy; /** * Unit tests for {@link BaseRepositoryBean}. diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CrudInheritanceRepositoryProxyTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CrudInheritanceRepositoryProxyTest.java index ce3a6730a..85a2c942d 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CrudInheritanceRepositoryProxyTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CrudInheritanceRepositoryProxyTest.java @@ -21,14 +21,14 @@ import org.eclipse.jnosql.communication.semistructured.Element; import org.eclipse.jnosql.communication.semistructured.SelectQuery; import org.eclipse.jnosql.mapping.NoSQLRepository; -import org.eclipse.jnosql.mapping.semistructured.EntityConverter; -import org.eclipse.jnosql.mapping.semistructured.SemiStructuredTemplate; -import org.eclipse.jnosql.mapping.semistructured.MockProducer; -import org.eclipse.jnosql.mapping.semistructured.entities.inheritance.EmailNotification; import org.eclipse.jnosql.mapping.core.Converters; -import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata; import org.eclipse.jnosql.mapping.reflection.Reflections; +import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; +import org.eclipse.jnosql.mapping.semistructured.EntityConverter; +import org.eclipse.jnosql.mapping.semistructured.MockProducer; +import org.eclipse.jnosql.mapping.semistructured.SemiStructuredTemplate; +import org.eclipse.jnosql.mapping.semistructured.entities.inheritance.EmailNotification; import org.jboss.weld.junit5.auto.AddExtensions; import org.jboss.weld.junit5.auto.AddPackages; import org.jboss.weld.junit5.auto.EnableAutoWeld; diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CrudRepositoryProxyIsTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CrudRepositoryProxyIsTest.java index b2eb3123a..ed9e8641f 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CrudRepositoryProxyIsTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CrudRepositoryProxyIsTest.java @@ -14,27 +14,14 @@ */ package org.eclipse.jnosql.mapping.semistructured.query; -import jakarta.data.Order; -import jakarta.data.Sort; import jakarta.data.constraint.GreaterThan; -import jakarta.data.page.CursoredPage; -import jakarta.data.page.Page; -import jakarta.data.page.PageRequest; import jakarta.data.repository.By; import jakarta.data.repository.CrudRepository; -import jakarta.data.repository.Delete; import jakarta.data.repository.Find; import jakarta.data.repository.Is; -import jakarta.data.repository.OrderBy; -import jakarta.data.repository.Param; -import jakarta.data.repository.Query; -import jakarta.data.restrict.Restriction; import jakarta.inject.Inject; import org.assertj.core.api.SoftAssertions; -import org.eclipse.jnosql.communication.Condition; -import org.eclipse.jnosql.communication.TypeReference; import org.eclipse.jnosql.communication.semistructured.CriteriaCondition; -import org.eclipse.jnosql.communication.semistructured.DeleteQuery; import org.eclipse.jnosql.communication.semistructured.Element; import org.eclipse.jnosql.communication.semistructured.SelectQuery; import org.eclipse.jnosql.mapping.core.Converters; @@ -59,7 +46,6 @@ import java.util.List; import java.util.stream.Stream; -import static org.eclipse.jnosql.communication.Condition.AND; import static org.eclipse.jnosql.communication.Condition.EQUALS; import static org.eclipse.jnosql.communication.Condition.GREATER_THAN; import static org.mockito.Mockito.any; diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CrudRepositoryProxyRestrictionTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CrudRepositoryProxyRestrictionTest.java index f4d7fe4a1..72c29b182 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CrudRepositoryProxyRestrictionTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CrudRepositoryProxyRestrictionTest.java @@ -28,17 +28,12 @@ import jakarta.data.repository.Query; import jakarta.data.restrict.Restriction; import jakarta.inject.Inject; -import org.assertj.core.api.Assertions; import org.assertj.core.api.SoftAssertions; -import org.eclipse.jnosql.communication.Condition; import org.eclipse.jnosql.communication.TypeReference; -import org.eclipse.jnosql.communication.Value; import org.eclipse.jnosql.communication.semistructured.CriteriaCondition; import org.eclipse.jnosql.communication.semistructured.DeleteQuery; import org.eclipse.jnosql.communication.semistructured.Element; import org.eclipse.jnosql.communication.semistructured.SelectQuery; -import org.eclipse.jnosql.mapping.NoSQLRepository; -import org.eclipse.jnosql.mapping.PreparedStatement; import org.eclipse.jnosql.mapping.core.Converters; import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata; import org.eclipse.jnosql.mapping.reflection.Reflections; @@ -46,10 +41,7 @@ import org.eclipse.jnosql.mapping.semistructured.EntityConverter; import org.eclipse.jnosql.mapping.semistructured.MockProducer; import org.eclipse.jnosql.mapping.semistructured.SemiStructuredTemplate; -import org.eclipse.jnosql.mapping.semistructured.entities.Address; -import org.eclipse.jnosql.mapping.semistructured.entities.Person; import org.eclipse.jnosql.mapping.semistructured.entities.Product; -import org.eclipse.jnosql.mapping.semistructured.entities.Vendor; import org.eclipse.jnosql.mapping.semistructured.entities._Product; import org.jboss.weld.junit5.auto.AddExtensions; import org.jboss.weld.junit5.auto.AddPackages; @@ -61,34 +53,13 @@ import java.lang.reflect.Proxy; import java.math.BigDecimal; -import java.time.Duration; -import java.util.Arrays; -import java.util.Collections; import java.util.List; -import java.util.Optional; -import java.util.Queue; -import java.util.Set; -import java.util.stream.Collectors; import java.util.stream.Stream; -import static java.util.Arrays.asList; -import static java.util.Collections.singletonList; -import static org.assertj.core.api.Assertions.assertThat; import static org.eclipse.jnosql.communication.Condition.AND; -import static org.eclipse.jnosql.communication.Condition.BETWEEN; import static org.eclipse.jnosql.communication.Condition.EQUALS; import static org.eclipse.jnosql.communication.Condition.GREATER_THAN; -import static org.eclipse.jnosql.communication.Condition.IN; -import static org.eclipse.jnosql.communication.Condition.LESSER_EQUALS_THAN; -import static org.eclipse.jnosql.communication.Condition.LESSER_THAN; -import static org.eclipse.jnosql.communication.Condition.LIKE; -import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNull; -import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.Mockito.any; -import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CrudRepositoryProxyTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CrudRepositoryProxyTest.java index f85d452c9..1da6f18b4 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CrudRepositoryProxyTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CrudRepositoryProxyTest.java @@ -14,18 +14,15 @@ */ package org.eclipse.jnosql.mapping.semistructured.query; +import jakarta.data.Sort; import jakarta.data.page.Page; import jakarta.data.page.PageRequest; import jakarta.data.repository.CrudRepository; import jakarta.data.repository.Param; import jakarta.data.repository.Query; -import jakarta.data.Sort; -import jakarta.data.restrict.Restriction; import jakarta.inject.Inject; -import org.assertj.core.api.SoftAssertions; -import org.eclipse.jnosql.mapping.NoSQLRepository; -import org.eclipse.jnosql.mapping.PreparedStatement; import org.assertj.core.api.Assertions; +import org.assertj.core.api.SoftAssertions; import org.eclipse.jnosql.communication.Condition; import org.eclipse.jnosql.communication.TypeReference; import org.eclipse.jnosql.communication.Value; @@ -33,17 +30,18 @@ import org.eclipse.jnosql.communication.semistructured.DeleteQuery; import org.eclipse.jnosql.communication.semistructured.Element; import org.eclipse.jnosql.communication.semistructured.SelectQuery; +import org.eclipse.jnosql.mapping.NoSQLRepository; +import org.eclipse.jnosql.mapping.PreparedStatement; import org.eclipse.jnosql.mapping.core.Converters; +import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata; +import org.eclipse.jnosql.mapping.reflection.Reflections; +import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; import org.eclipse.jnosql.mapping.semistructured.EntityConverter; import org.eclipse.jnosql.mapping.semistructured.MockProducer; import org.eclipse.jnosql.mapping.semistructured.SemiStructuredTemplate; import org.eclipse.jnosql.mapping.semistructured.entities.Address; import org.eclipse.jnosql.mapping.semistructured.entities.Person; -import org.eclipse.jnosql.mapping.semistructured.entities.Product; import org.eclipse.jnosql.mapping.semistructured.entities.Vendor; -import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata; -import org.eclipse.jnosql.mapping.reflection.Reflections; -import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; import org.jboss.weld.junit5.auto.AddExtensions; import org.jboss.weld.junit5.auto.AddPackages; import org.jboss.weld.junit5.auto.EnableAutoWeld; @@ -67,9 +65,23 @@ import static java.util.Arrays.asList; import static java.util.Collections.singletonList; import static org.assertj.core.api.Assertions.assertThat; -import static org.eclipse.jnosql.communication.Condition.*; -import static org.junit.jupiter.api.Assertions.*; -import static org.mockito.Mockito.*; +import static org.eclipse.jnosql.communication.Condition.AND; +import static org.eclipse.jnosql.communication.Condition.BETWEEN; +import static org.eclipse.jnosql.communication.Condition.EQUALS; +import static org.eclipse.jnosql.communication.Condition.GREATER_THAN; +import static org.eclipse.jnosql.communication.Condition.IN; +import static org.eclipse.jnosql.communication.Condition.LESSER_EQUALS_THAN; +import static org.eclipse.jnosql.communication.Condition.LESSER_THAN; +import static org.eclipse.jnosql.communication.Condition.LIKE; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.Mockito.any; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; @EnableAutoWeld @AddPackages(value = {Converters.class, EntityConverter.class}) diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CustomRepositoryHandlerRestrictionTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CustomRepositoryHandlerRestrictionTest.java index fb89f0a69..c898368b8 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CustomRepositoryHandlerRestrictionTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CustomRepositoryHandlerRestrictionTest.java @@ -19,19 +19,14 @@ import jakarta.data.page.CursoredPage; import jakarta.data.page.Page; import jakarta.data.page.PageRequest; -import jakarta.data.repository.CrudRepository; import jakarta.data.repository.Find; import jakarta.data.repository.OrderBy; -import jakarta.data.restrict.Restrict; import jakarta.data.restrict.Restriction; import jakarta.inject.Inject; -import org.assertj.core.api.Assertions; import org.assertj.core.api.SoftAssertions; -import org.eclipse.jnosql.communication.Condition; import org.eclipse.jnosql.communication.semistructured.CriteriaCondition; import org.eclipse.jnosql.communication.semistructured.Element; import org.eclipse.jnosql.communication.semistructured.SelectQuery; -import org.eclipse.jnosql.mapping.PreparedStatement; import org.eclipse.jnosql.mapping.core.Converters; import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata; import org.eclipse.jnosql.mapping.reflection.Reflections; @@ -39,9 +34,7 @@ import org.eclipse.jnosql.mapping.semistructured.EntityConverter; import org.eclipse.jnosql.mapping.semistructured.MockProducer; import org.eclipse.jnosql.mapping.semistructured.SemiStructuredTemplate; -import org.eclipse.jnosql.mapping.semistructured.entities.Person; import org.eclipse.jnosql.mapping.semistructured.entities.Product; -import org.eclipse.jnosql.mapping.semistructured.entities.Task; import org.eclipse.jnosql.mapping.semistructured.entities._Product; import org.jboss.weld.junit5.auto.AddExtensions; import org.jboss.weld.junit5.auto.AddPackages; @@ -53,8 +46,6 @@ import java.lang.reflect.Proxy; import java.util.List; -import java.util.Optional; -import java.util.Set; import java.util.stream.Stream; import static org.eclipse.jnosql.communication.Condition.EQUALS; diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CustomRepositoryHandlerTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CustomRepositoryHandlerTest.java index b82e014a4..ec3d49a83 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CustomRepositoryHandlerTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CustomRepositoryHandlerTest.java @@ -24,9 +24,9 @@ import org.eclipse.jnosql.communication.semistructured.SelectQuery; import org.eclipse.jnosql.mapping.PreparedStatement; import org.eclipse.jnosql.mapping.core.Converters; -import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata; import org.eclipse.jnosql.mapping.reflection.Reflections; +import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; import org.eclipse.jnosql.mapping.semistructured.EntityConverter; import org.eclipse.jnosql.mapping.semistructured.MockProducer; import org.eclipse.jnosql.mapping.semistructured.SemiStructuredTemplate; diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/DynamicQueryTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/DynamicQueryTest.java index b46d04f74..772e926d6 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/DynamicQueryTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/DynamicQueryTest.java @@ -15,8 +15,8 @@ package org.eclipse.jnosql.mapping.semistructured.query; import jakarta.data.Limit; -import jakarta.data.page.PageRequest; import jakarta.data.Sort; +import jakarta.data.page.PageRequest; import org.eclipse.jnosql.communication.semistructured.SelectQuery; import org.eclipse.jnosql.mapping.core.repository.SpecialParameters; import org.junit.jupiter.api.BeforeEach; diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/ParamsBinderTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/ParamsBinderTest.java index 974a2f60d..6ce473933 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/ParamsBinderTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/ParamsBinderTest.java @@ -25,14 +25,14 @@ import org.eclipse.jnosql.communication.semistructured.QueryParams; import org.eclipse.jnosql.communication.semistructured.SelectQueryParser; import org.eclipse.jnosql.mapping.core.Converters; -import org.eclipse.jnosql.mapping.semistructured.EntityConverter; -import org.eclipse.jnosql.mapping.semistructured.MockProducer; -import org.eclipse.jnosql.mapping.semistructured.entities.Person; +import org.eclipse.jnosql.mapping.core.util.ParamsBinder; import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata; import org.eclipse.jnosql.mapping.metadata.EntityMetadata; import org.eclipse.jnosql.mapping.reflection.Reflections; import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; -import org.eclipse.jnosql.mapping.core.util.ParamsBinder; +import org.eclipse.jnosql.mapping.semistructured.EntityConverter; +import org.eclipse.jnosql.mapping.semistructured.MockProducer; +import org.eclipse.jnosql.mapping.semistructured.entities.Person; import org.jboss.weld.junit5.auto.AddExtensions; import org.jboss.weld.junit5.auto.AddPackages; import org.jboss.weld.junit5.auto.EnableAutoWeld; diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/RepositoryBeanTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/RepositoryBeanTest.java index 4262b6497..8b454a82e 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/RepositoryBeanTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/RepositoryBeanTest.java @@ -14,8 +14,8 @@ */ package org.eclipse.jnosql.mapping.semistructured.query; -import jakarta.enterprise.context.spi.CreationalContext; import jakarta.data.repository.DataRepository; +import jakarta.enterprise.context.spi.CreationalContext; import org.assertj.core.api.SoftAssertions; import org.eclipse.jnosql.mapping.DatabaseType; import org.eclipse.jnosql.mapping.core.Converters; @@ -28,7 +28,11 @@ import java.util.Set; import static org.assertj.core.api.Assertions.assertThat; -import static org.mockito.Mockito.*; +import static org.mockito.Mockito.any; +import static org.mockito.Mockito.doReturn; +import static org.mockito.Mockito.eq; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.spy; class RepositoryBeanTest { diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/RepositoryProxyPageRequestTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/RepositoryProxyPageRequestTest.java index 87c8822e5..91c353995 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/RepositoryProxyPageRequestTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/RepositoryProxyPageRequestTest.java @@ -16,11 +16,11 @@ import jakarta.data.Limit; import jakarta.data.Order; +import jakarta.data.Sort; import jakarta.data.page.CursoredPage; import jakarta.data.page.Page; import jakarta.data.page.PageRequest; import jakarta.data.repository.BasicRepository; -import jakarta.data.Sort; import jakarta.data.repository.By; import jakarta.data.repository.Find; import jakarta.data.repository.Param; @@ -35,14 +35,14 @@ import org.eclipse.jnosql.communication.semistructured.SelectQuery; import org.eclipse.jnosql.mapping.core.Converters; import org.eclipse.jnosql.mapping.core.NoSQLPage; +import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata; +import org.eclipse.jnosql.mapping.reflection.Reflections; +import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; import org.eclipse.jnosql.mapping.semistructured.EntityConverter; -import org.eclipse.jnosql.mapping.semistructured.SemiStructuredTemplate; import org.eclipse.jnosql.mapping.semistructured.MockProducer; +import org.eclipse.jnosql.mapping.semistructured.SemiStructuredTemplate; import org.eclipse.jnosql.mapping.semistructured.entities.Person; import org.eclipse.jnosql.mapping.semistructured.entities.Vendor; -import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata; -import org.eclipse.jnosql.mapping.reflection.Reflections; -import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; import org.jboss.weld.junit5.auto.AddExtensions; import org.jboss.weld.junit5.auto.AddPackages; import org.jboss.weld.junit5.auto.EnableAutoWeld; @@ -65,8 +65,19 @@ import static java.util.Collections.singletonList; import static org.assertj.core.api.Assertions.assertThat; -import static org.eclipse.jnosql.communication.Condition.*; -import static org.junit.jupiter.api.Assertions.*; +import static org.eclipse.jnosql.communication.Condition.AND; +import static org.eclipse.jnosql.communication.Condition.BETWEEN; +import static org.eclipse.jnosql.communication.Condition.EQUALS; +import static org.eclipse.jnosql.communication.Condition.GREATER_THAN; +import static org.eclipse.jnosql.communication.Condition.IN; +import static org.eclipse.jnosql.communication.Condition.LESSER_EQUALS_THAN; +import static org.eclipse.jnosql.communication.Condition.LESSER_THAN; +import static org.eclipse.jnosql.communication.Condition.LIKE; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; import static org.mockito.ArgumentMatchers.any; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/RepositoryProxyTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/RepositoryProxyTest.java index e91403957..ac77a15ed 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/RepositoryProxyTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/RepositoryProxyTest.java @@ -14,20 +14,18 @@ */ package org.eclipse.jnosql.mapping.semistructured.query; -import jakarta.data.exceptions.MappingException; +import jakarta.data.Sort; +import jakarta.data.repository.BasicRepository; import jakarta.data.repository.By; import jakarta.data.repository.Delete; import jakarta.data.repository.Find; import jakarta.data.repository.Insert; import jakarta.data.repository.OrderBy; -import jakarta.data.repository.BasicRepository; import jakarta.data.repository.Param; import jakarta.data.repository.Query; -import jakarta.data.Sort; import jakarta.data.repository.Save; import jakarta.data.repository.Update; import jakarta.inject.Inject; -import org.eclipse.jnosql.mapping.PreparedStatement; import org.assertj.core.api.SoftAssertions; import org.eclipse.jnosql.communication.Condition; import org.eclipse.jnosql.communication.TypeReference; @@ -37,16 +35,17 @@ import org.eclipse.jnosql.communication.semistructured.Element; import org.eclipse.jnosql.communication.semistructured.SelectQuery; import org.eclipse.jnosql.mapping.NoSQLRepository; +import org.eclipse.jnosql.mapping.PreparedStatement; import org.eclipse.jnosql.mapping.core.Converters; +import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata; +import org.eclipse.jnosql.mapping.reflection.Reflections; +import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; import org.eclipse.jnosql.mapping.semistructured.EntityConverter; -import org.eclipse.jnosql.mapping.semistructured.SemiStructuredTemplate; import org.eclipse.jnosql.mapping.semistructured.MockProducer; +import org.eclipse.jnosql.mapping.semistructured.SemiStructuredTemplate; import org.eclipse.jnosql.mapping.semistructured.entities.Person; import org.eclipse.jnosql.mapping.semistructured.entities.PersonStatisticRepository; import org.eclipse.jnosql.mapping.semistructured.entities.Vendor; -import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata; -import org.eclipse.jnosql.mapping.reflection.Reflections; -import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; import org.jboss.weld.junit5.auto.AddExtensions; import org.jboss.weld.junit5.auto.AddPackages; import org.jboss.weld.junit5.auto.EnableAutoWeld; @@ -74,9 +73,23 @@ import static java.util.Arrays.asList; import static java.util.Collections.singletonList; import static org.assertj.core.api.Assertions.assertThat; -import static org.eclipse.jnosql.communication.Condition.*; -import static org.junit.jupiter.api.Assertions.*; -import static org.mockito.Mockito.*; +import static org.eclipse.jnosql.communication.Condition.AND; +import static org.eclipse.jnosql.communication.Condition.BETWEEN; +import static org.eclipse.jnosql.communication.Condition.EQUALS; +import static org.eclipse.jnosql.communication.Condition.GREATER_THAN; +import static org.eclipse.jnosql.communication.Condition.IN; +import static org.eclipse.jnosql.communication.Condition.LESSER_EQUALS_THAN; +import static org.eclipse.jnosql.communication.Condition.LESSER_THAN; +import static org.eclipse.jnosql.communication.Condition.LIKE; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertFalse; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertTrue; +import static org.mockito.Mockito.any; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; @EnableAutoWeld @AddPackages(value = {Converters.class, EntityConverter.class}) diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/RepositorySemiStructuredObserverParserTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/RepositorySemiStructuredObserverParserTest.java index 788e58ef7..f078b3391 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/RepositorySemiStructuredObserverParserTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/RepositorySemiStructuredObserverParserTest.java @@ -16,10 +16,10 @@ import jakarta.inject.Inject; import org.eclipse.jnosql.mapping.core.Converters; -import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata; import org.eclipse.jnosql.mapping.metadata.EntityMetadata; import org.eclipse.jnosql.mapping.reflection.Reflections; +import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; import org.eclipse.jnosql.mapping.semistructured.EntityConverter; import org.eclipse.jnosql.mapping.semistructured.MockProducer; import org.eclipse.jnosql.mapping.semistructured.entities.Person; @@ -30,7 +30,8 @@ import org.junit.jupiter.api.Test; import org.mockito.Mockito; -import static org.junit.jupiter.api.Assertions.*; +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotNull; @EnableAutoWeld @AddPackages(value = {Converters.class, EntityConverter.class}) diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java index 99e21ec3d..75851f6c7 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/SemiStructuredParameterBasedQueryTest.java @@ -23,15 +23,15 @@ import org.eclipse.jnosql.communication.TypeReference; import org.eclipse.jnosql.communication.semistructured.CriteriaCondition; import org.eclipse.jnosql.communication.semistructured.Element; -import org.eclipse.jnosql.mapping.core.repository.ParamValue; -import org.eclipse.jnosql.mapping.semistructured.EntityConverter; -import org.eclipse.jnosql.mapping.semistructured.MockProducer; -import org.eclipse.jnosql.mapping.semistructured.entities.Person; import org.eclipse.jnosql.mapping.core.Converters; -import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; +import org.eclipse.jnosql.mapping.core.repository.ParamValue; import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata; import org.eclipse.jnosql.mapping.metadata.EntityMetadata; import org.eclipse.jnosql.mapping.reflection.Reflections; +import org.eclipse.jnosql.mapping.reflection.spi.ReflectionEntityMetadataExtension; +import org.eclipse.jnosql.mapping.semistructured.EntityConverter; +import org.eclipse.jnosql.mapping.semistructured.MockProducer; +import org.eclipse.jnosql.mapping.semistructured.entities.Person; import org.jboss.weld.junit5.auto.AddExtensions; import org.jboss.weld.junit5.auto.AddPackages; import org.jboss.weld.junit5.auto.EnableAutoWeld; From ddb58e8683b311538b2932c4e6938d727c38a7c3 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Wed, 2 Jul 2025 21:06:20 +0100 Subject: [PATCH 29/33] test: include crud repository proxy Signed-off-by: Otavio Santana --- .../query/CrudRepositoryProxyIsTest.java | 52 +++++++++++++++++++ 1 file changed, 52 insertions(+) diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CrudRepositoryProxyIsTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CrudRepositoryProxyIsTest.java index ed9e8641f..73ef07f9a 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CrudRepositoryProxyIsTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CrudRepositoryProxyIsTest.java @@ -15,6 +15,8 @@ package org.eclipse.jnosql.mapping.semistructured.query; import jakarta.data.constraint.GreaterThan; +import jakarta.data.constraint.In; +import jakarta.data.constraint.LessThan; import jakarta.data.repository.By; import jakarta.data.repository.CrudRepository; import jakarta.data.repository.Find; @@ -48,6 +50,8 @@ import static org.eclipse.jnosql.communication.Condition.EQUALS; import static org.eclipse.jnosql.communication.Condition.GREATER_THAN; +import static org.eclipse.jnosql.communication.Condition.IN; +import static org.eclipse.jnosql.communication.Condition.LESSER_THAN; import static org.mockito.Mockito.any; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -127,6 +131,48 @@ void shouldAtLeast() { }); } + @Test + void shouldLesser() { + + when(template.select(any(SelectQuery.class))) + .thenReturn(Stream.of(new Product())); + + repository.lesserThan(BigDecimal.TEN); + ArgumentCaptor captor = ArgumentCaptor.forClass(SelectQuery.class); + verify(template).select(captor.capture()); + SelectQuery query = captor.getValue(); + + SoftAssertions.assertSoftly(softly -> { + softly.assertThat(query.name()).isEqualTo("Product"); + softly.assertThat(query.condition()).isPresent(); + CriteriaCondition condition = query.condition().orElseThrow(); + softly.assertThat(condition).isInstanceOf(CriteriaCondition.class); + softly.assertThat(condition.condition()).isEqualTo(LESSER_THAN); + softly.assertThat(condition.element()).isEqualTo(Element.of(_Product.PRICE, BigDecimal.TEN)); + }); + } + + @Test + void shouldIn() { + + when(template.select(any(SelectQuery.class))) + .thenReturn(Stream.of(new Product())); + + repository.in(List.of("Mac", "Iphone")); + ArgumentCaptor captor = ArgumentCaptor.forClass(SelectQuery.class); + verify(template).select(captor.capture()); + SelectQuery query = captor.getValue(); + + SoftAssertions.assertSoftly(softly -> { + softly.assertThat(query.name()).isEqualTo("Product"); + softly.assertThat(query.condition()).isPresent(); + CriteriaCondition condition = query.condition().orElseThrow(); + softly.assertThat(condition).isInstanceOf(CriteriaCondition.class); + softly.assertThat(condition.condition()).isEqualTo(IN); + softly.assertThat(condition.element()).isEqualTo(Element.of(_Product.NAME, List.of("Mac", "Iphone"))); + }); + } + public interface ProductRepository extends CrudRepository { @Find @@ -134,6 +180,12 @@ public interface ProductRepository extends CrudRepository { @Find List greaterThan(@By(_Product.PRICE) @Is(GreaterThan.class) BigDecimal price); + + @Find + List lesserThan(@By(_Product.PRICE) @Is(LessThan.class) BigDecimal price); + + @Find + List in(@By(_Product.NAME) @Is(In.class) List names); } } From 26e77aa83d8787b94897499926b351c06222f72f Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Wed, 2 Jul 2025 21:18:09 +0100 Subject: [PATCH 30/33] test: update shouldNot in Signed-off-by: Otavio Santana --- .../query/CrudRepositoryProxyIsTest.java | 55 +++++++++++++++++++ 1 file changed, 55 insertions(+) diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CrudRepositoryProxyIsTest.java b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CrudRepositoryProxyIsTest.java index 73ef07f9a..356c1a9a5 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CrudRepositoryProxyIsTest.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/test/java/org/eclipse/jnosql/mapping/semistructured/query/CrudRepositoryProxyIsTest.java @@ -17,12 +17,14 @@ import jakarta.data.constraint.GreaterThan; import jakarta.data.constraint.In; import jakarta.data.constraint.LessThan; +import jakarta.data.constraint.NotIn; import jakarta.data.repository.By; import jakarta.data.repository.CrudRepository; import jakarta.data.repository.Find; import jakarta.data.repository.Is; import jakarta.inject.Inject; import org.assertj.core.api.SoftAssertions; +import org.eclipse.jnosql.communication.Condition; import org.eclipse.jnosql.communication.semistructured.CriteriaCondition; import org.eclipse.jnosql.communication.semistructured.Element; import org.eclipse.jnosql.communication.semistructured.SelectQuery; @@ -52,6 +54,7 @@ import static org.eclipse.jnosql.communication.Condition.GREATER_THAN; import static org.eclipse.jnosql.communication.Condition.IN; import static org.eclipse.jnosql.communication.Condition.LESSER_THAN; +import static org.eclipse.jnosql.communication.Condition.NOT; import static org.mockito.Mockito.any; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -110,6 +113,28 @@ void shouldEquals() { }); } + + @Test + void shouldDefaultMethod() { + + when(template.select(any(SelectQuery.class))) + .thenReturn(Stream.of(new Product())); + + repository.defaultMethod("Mac"); + ArgumentCaptor captor = ArgumentCaptor.forClass(SelectQuery.class); + verify(template).select(captor.capture()); + SelectQuery query = captor.getValue(); + + SoftAssertions.assertSoftly(softly -> { + softly.assertThat(query.name()).isEqualTo("Product"); + softly.assertThat(query.condition()).isPresent(); + CriteriaCondition condition = query.condition().orElseThrow(); + softly.assertThat(condition).isInstanceOf(CriteriaCondition.class); + softly.assertThat(condition.condition()).isEqualTo(EQUALS); + softly.assertThat(condition.element()).isEqualTo(Element.of(_Product.NAME, "Mac")); + }); + } + @Test void shouldAtLeast() { @@ -173,8 +198,35 @@ void shouldIn() { }); } + @Test + void shouldNotIn() { + + when(template.select(any(SelectQuery.class))) + .thenReturn(Stream.of(new Product())); + + repository.notIn(List.of("Mac", "Iphone")); + ArgumentCaptor captor = ArgumentCaptor.forClass(SelectQuery.class); + verify(template).select(captor.capture()); + SelectQuery query = captor.getValue(); + + SoftAssertions.assertSoftly(softly -> { + softly.assertThat(query.name()).isEqualTo("Product"); + softly.assertThat(query.condition()).isPresent(); + CriteriaCondition condition = query.condition().orElseThrow(); + softly.assertThat(condition).isInstanceOf(CriteriaCondition.class); + softly.assertThat(condition.condition()).isEqualTo(NOT); + var criteriaCondition = condition.element().get(CriteriaCondition.class); + softly.assertThat(criteriaCondition.condition()).isEqualTo(IN); + softly.assertThat(criteriaCondition.element()).isEqualTo(Element.of(_Product.NAME, List.of("Mac", "Iphone"))); + }); + } + + public interface ProductRepository extends CrudRepository { + @Find + List defaultMethod(@By(_Product.NAME) String name); + @Find List equals(@By(_Product.NAME) @Is String name); @@ -186,6 +238,9 @@ public interface ProductRepository extends CrudRepository { @Find List in(@By(_Product.NAME) @Is(In.class) List names); + + @Find + List notIn(@By(_Product.NAME) @Is(NotIn.class) List names); } } From fb54ddbcfb2490018ed5f34340bf68ded163c268 Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Wed, 2 Jul 2025 21:20:41 +0100 Subject: [PATCH 31/33] docs: update documentation on changelog Signed-off-by: Otavio Santana --- CHANGELOG.adoc | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.adoc b/CHANGELOG.adoc index 1f4806fab..78767cb05 100644 --- a/CHANGELOG.adoc +++ b/CHANGELOG.adoc @@ -21,6 +21,7 @@ and this project adheres to https://semver.org/spec/v2.0.0.html[Semantic Version - Include support to Restriction interface - Include support to record projector +- Include Is annotation support to the Repository == [1.1.8] - 2025-05-21 From 75011cedca8931e34be7566ee5426b4f041d3fcc Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 3 Jul 2025 09:23:05 +0100 Subject: [PATCH 32/33] chore: update snapshot version to 1.0.2 Signed-off-by: Otavio Santana --- pom.xml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pom.xml b/pom.xml index 83bb97e8c..387443134 100644 --- a/pom.xml +++ b/pom.xml @@ -65,7 +65,7 @@ 3.0.1 2.1.3 1.1.0-SNAPSHOT - 1.0.0 + 1.0.2-SNAPSHOT 3.1.1 3.11.1 3.3.1 From df564af867d1f60362d56c5b42aa16ea6e05f9cf Mon Sep 17 00:00:00 2001 From: Otavio Santana Date: Thu, 3 Jul 2025 09:34:05 +0100 Subject: [PATCH 33/33] feat: include new methods from Template Signed-off-by: Otavio Santana --- .../AbstractSemiStructuredTemplate.java | 22 +++++++++++++++++++ 1 file changed, 22 insertions(+) diff --git a/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/AbstractSemiStructuredTemplate.java b/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/AbstractSemiStructuredTemplate.java index 2082d7018..dd74717fe 100644 --- a/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/AbstractSemiStructuredTemplate.java +++ b/jnosql-mapping/jnosql-mapping-semistructured/src/main/java/org/eclipse/jnosql/mapping/semistructured/AbstractSemiStructuredTemplate.java @@ -40,6 +40,7 @@ import java.time.Duration; import java.util.Iterator; import java.util.List; +import java.util.Objects; import java.util.Optional; import java.util.function.Consumer; import java.util.function.Function; @@ -148,6 +149,27 @@ public Iterable insert(Iterable entities, Duration ttl) { .collect(Collectors.toList()); } + @Override + public void delete(T entity) { + Objects.requireNonNull(entity, "entity is required"); + EntityMetadata metadata = entities().get(entity.getClass()); + FieldMetadata idField = metadata.id() + .orElseThrow(() -> IdNotFoundException.newInstance(metadata.type())); + + var idValue = idField.read(entity); + LOGGER.fine("Deleting entity: " + entity.getClass() + " with id: " + idValue); + DeleteQuery query = DeleteQuery.delete().from(metadata.name()) + .where(idField.name()).eq(idValue).build(); + manager().delete(query); + } + + @Override + public void delete(Iterable iterable) { + Objects.requireNonNull(iterable, "iterable is required"); + StreamSupport.stream(iterable.spliterator(), false) + .forEach(this::delete); + } + @Override public void delete(DeleteQuery query) { requireNonNull(query, "query is required");