Skip to content

Commit

Permalink
test: create query to column template
Browse files Browse the repository at this point in the history
Signed-off-by: Otavio Santana <otaviopolianasantana@gmail.com>
  • Loading branch information
otaviojava committed Jan 27, 2024
1 parent 600365a commit cb81226
Show file tree
Hide file tree
Showing 3 changed files with 237 additions and 3 deletions.
Expand Up @@ -15,9 +15,13 @@
package org.eclipse.jnosql.mapping.column.query;


import jakarta.data.Limit;
import jakarta.data.Sort;
import jakarta.data.page.Page;
import jakarta.data.page.Pageable;
import org.eclipse.jnosql.communication.Params;
import org.eclipse.jnosql.communication.column.Column;
import org.eclipse.jnosql.communication.column.ColumnCondition;
import org.eclipse.jnosql.communication.column.ColumnDeleteQuery;
import org.eclipse.jnosql.communication.column.ColumnDeleteQueryParams;
import org.eclipse.jnosql.communication.column.ColumnObserverParser;
Expand All @@ -29,15 +33,20 @@
import org.eclipse.jnosql.communication.query.SelectQuery;
import org.eclipse.jnosql.communication.query.method.DeleteMethodProvider;
import org.eclipse.jnosql.communication.query.method.SelectMethodProvider;
import org.eclipse.jnosql.mapping.column.MappingColumnQuery;
import org.eclipse.jnosql.mapping.core.Converters;
import org.eclipse.jnosql.mapping.core.NoSQLPage;
import org.eclipse.jnosql.mapping.column.JNoSQLColumnTemplate;
import org.eclipse.jnosql.mapping.core.query.AbstractRepositoryProxy;
import org.eclipse.jnosql.mapping.core.repository.SpecialParameters;
import org.eclipse.jnosql.mapping.metadata.EntityMetadata;
import org.eclipse.jnosql.mapping.core.repository.DynamicReturn;
import org.eclipse.jnosql.mapping.core.util.ParamsBinder;
import org.eclipse.jnosql.mapping.metadata.InheritanceMetadata;

import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Optional;
import java.util.function.Function;
Expand Down Expand Up @@ -146,6 +155,24 @@ protected Object executeFindByQuery(Method method, Object[] args, Class<?> typeC
return dynamicReturn.execute();
}

private ColumnQuery includeInheritance(ColumnQuery query){
EntityMetadata metadata = this.entityMetadata();
if(metadata.inheritance().isPresent()){
InheritanceMetadata inheritanceMetadata = metadata.inheritance().orElseThrow();
if(!inheritanceMetadata.parent().equals(metadata.type())){
ColumnCondition condition = ColumnCondition.eq(Column.of(inheritanceMetadata.discriminatorColumn(),
inheritanceMetadata.discriminatorValue()));
if(query.condition().isPresent()){
ColumnCondition columnCondition = query.condition().orElseThrow();
condition = condition.and(columnCondition);
}
return new MappingColumnQuery(query.sorts(), query.limit(), query.skip(),
condition, query.name());
}
}
return query;
}

protected Long executeCountByQuery(ColumnQuery query) {
return template().count(query);
}
Expand All @@ -155,6 +182,7 @@ protected boolean executeExistsByQuery(ColumnQuery query) {
}



protected Function<Pageable, Page<T>> getPage(ColumnQuery query) {
return p -> {
Stream<T> entities = template().select(query);
Expand All @@ -172,8 +200,46 @@ protected Function<Pageable, Stream<T>> streamPagination(ColumnQuery query) {


protected ColumnQuery updateQueryDynamically(Object[] args, ColumnQuery query) {
DynamicQuery dynamicQuery = DynamicQuery.of(args, query);
return dynamicQuery.get();
ColumnQuery documentQuery = includeInheritance(query);
SpecialParameters special = DynamicReturn.findSpecialParameters(args);

if (special.isEmpty()) {
return documentQuery;
}
Optional<Limit> limit = special.limit();

if (special.hasOnlySort()) {
List<Sort> sorts = new ArrayList<>();
sorts.addAll(documentQuery.sorts());
sorts.addAll(special.sorts());
long skip = limit.map(l -> l.startAt() - 1).orElse(documentQuery.skip());
long max = limit.map(Limit::maxResults).orElse((int) documentQuery.limit());
return new MappingColumnQuery(sorts, max,
skip,
documentQuery.condition().orElse(null),
documentQuery.name());
}

if (limit.isPresent()) {
long skip = limit.map(l -> l.startAt() - 1).orElse(documentQuery.skip());
long max = limit.map(Limit::maxResults).orElse((int) documentQuery.limit());
return new MappingColumnQuery(documentQuery.sorts(), max,
skip,
documentQuery.condition().orElse(null),
documentQuery.name());
}

return special.pageable().<ColumnQuery>map(p -> {
long size = p.size();
long skip = NoSQLPage.skip(p);
List<Sort> sorts = documentQuery.sorts();
if (!special.sorts().isEmpty()) {
sorts = new ArrayList<>(documentQuery.sorts());
sorts.addAll(special.sorts());
}
return new MappingColumnQuery(sorts, size, skip,
documentQuery.condition().orElse(null), documentQuery.name());
}).orElse(documentQuery);
}


Expand Down
Expand Up @@ -18,6 +18,7 @@
import jakarta.enterprise.inject.Instance;
import jakarta.inject.Inject;
import jakarta.nosql.PreparedStatement;
import org.assertj.core.api.SoftAssertions;
import org.eclipse.jnosql.communication.column.Column;
import org.eclipse.jnosql.communication.column.ColumnCondition;
import org.eclipse.jnosql.communication.column.ColumnDeleteQuery;
Expand Down Expand Up @@ -420,7 +421,12 @@ void shouldCount() {
@Test
void shouldCountFromEntityClass() {
template.count(Person.class);
verify(managerMock).count("Person");
var captor = ArgumentCaptor.forClass(ColumnQuery.class);
verify(managerMock).count(captor.capture());
var query = captor.getValue();
SoftAssertions.assertSoftly(soft ->{
soft.assertThat(query.condition()).isEmpty();
});
}


Expand Down
@@ -0,0 +1,162 @@
/*
* Copyright (c) 2024 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.column.query;


import jakarta.data.repository.CrudRepository;
import jakarta.inject.Inject;
import org.eclipse.jnosql.communication.TypeReference;
import org.eclipse.jnosql.communication.column.Column;
import org.eclipse.jnosql.communication.column.ColumnCondition;
import org.eclipse.jnosql.communication.column.ColumnQuery;
import org.eclipse.jnosql.mapping.column.ColumnEntityConverter;
import org.eclipse.jnosql.mapping.column.JNoSQLColumnTemplate;
import org.eclipse.jnosql.mapping.column.MockProducer;
import org.eclipse.jnosql.mapping.column.entities.inheritance.EmailNotification;
import org.eclipse.jnosql.mapping.column.spi.ColumnExtension;
import org.eclipse.jnosql.mapping.core.Converters;
import org.eclipse.jnosql.mapping.core.spi.EntityMetadataExtension;
import org.eclipse.jnosql.mapping.metadata.EntitiesMetadata;
import org.eclipse.jnosql.mapping.reflection.Reflections;
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.util.List;

import static org.assertj.core.api.SoftAssertions.assertSoftly;
import static org.eclipse.jnosql.communication.Condition.AND;
import static org.mockito.Mockito.verify;

@EnableAutoWeld
@AddPackages(value = {Converters.class, ColumnEntityConverter.class})
@AddPackages(MockProducer.class)
@AddPackages(Reflections.class)
@AddExtensions({EntityMetadataExtension.class, ColumnExtension.class})
class ColumnCrudInheritanceRepositoryProxyTest {

private JNoSQLColumnTemplate template;

@Inject
private EntitiesMetadata entities;

@Inject
private Converters converters;

private EmailRepository emailRepository;



@BeforeEach
public void setUp() {
this.template = Mockito.mock(JNoSQLColumnTemplate.class);

ColumnRepositoryProxy<EmailNotification, Long> personHandler = new ColumnRepositoryProxy<>(template,
entities, EmailRepository.class, converters);


emailRepository = (EmailRepository) Proxy.newProxyInstance(EmailRepository.class.getClassLoader(),
new Class[]{EmailRepository.class},
personHandler);
}

@Test
void shouldPutFilterAtFindAll() {
emailRepository.findAll();
verify(template).findAll(EmailNotification.class);
}

@Test
void shouldPutFilterAtDeleteAll() {
emailRepository.deleteAll();
verify(template).deleteAll(EmailNotification.class);
}

@Test
void shouldPutFilterAtCount() {
emailRepository.count();
verify(template).count(EmailNotification.class);
}

@Test
void shouldPutFilterAtFindByName() {
emailRepository.findByName("name");
ArgumentCaptor<ColumnQuery> captor = ArgumentCaptor.forClass(ColumnQuery.class);
verify(template).select(captor.capture());
ColumnQuery query = captor.getValue();
assertSoftly(soft ->{
soft.assertThat(query.name()).isEqualTo("Notification");
soft.assertThat(query.condition()).isPresent();
ColumnCondition condition = query.condition().orElseThrow();
soft.assertThat(condition.condition()).isEqualTo(AND);
var conditions = condition.column().get(new TypeReference<List<ColumnCondition>>() {
});
soft.assertThat(conditions).hasSize(2).contains(ColumnCondition.eq(Column.of("dtype", "Email")));
});
}

@Test
void shouldPutFilterAtCountByName() {
emailRepository.countByName("name");
ArgumentCaptor<ColumnQuery> captor = ArgumentCaptor.forClass(ColumnQuery.class);
verify(template).count(captor.capture());
ColumnQuery query = captor.getValue();
assertSoftly(soft ->{
soft.assertThat(query.name()).isEqualTo("Notification");
soft.assertThat(query.condition()).isPresent();
ColumnCondition condition = query.condition().orElseThrow();
soft.assertThat(condition.condition()).isEqualTo(AND);
var conditions = condition.column().get(new TypeReference<List<ColumnCondition>>() {
});
soft.assertThat(conditions).hasSize(2).contains(ColumnCondition.eq(Column.of("dtype", "Email")));
});
}


@Test
void shouldPutFilterAtExistByName() {
emailRepository.existsByName("name");
ArgumentCaptor<ColumnQuery> captor = ArgumentCaptor.forClass(ColumnQuery.class);
verify(template).exists(captor.capture());
ColumnQuery query = captor.getValue();
assertSoftly(soft ->{
soft.assertThat(query.name()).isEqualTo("Notification");
soft.assertThat(query.condition()).isPresent();
ColumnCondition condition = query.condition().orElseThrow();
soft.assertThat(condition.condition()).isEqualTo(AND);
var conditions = condition.column().get(new TypeReference<List<ColumnCondition>>() {
});
soft.assertThat(conditions).hasSize(2).contains(ColumnCondition.eq(Column.of("dtype", "Email")));
});
}



public interface EmailRepository extends CrudRepository<EmailNotification, String> {

List<EmailNotification> findByName(String name);

long countByName(String name);

boolean existsByName(String name);


}
}

0 comments on commit cb81226

Please sign in to comment.