Skip to content

Instantly share code, notes, and snippets.

Embed
What would you like to do?
AEM Query test
//src: https://github.com/Adobe-Consulting-Services/acs-aem-commons/blob/24486e39452401d149493786c998247653963a08/bundle/src/test/java/com/adobe/acs/commons/search/impl/CloseableQueryBuilderImplTest.java
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.mockito.Matchers.any;
import static org.mockito.Matchers.anyBoolean;
import static org.mockito.Matchers.isA;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import java.util.Collections;
import javax.jcr.Session;
import com.adobe.acs.commons.search.CloseableQuery;
import com.adobe.acs.commons.search.CloseableQueryBuilder;
import com.adobe.acs.commons.wrap.cqsearch.QueryIWrap;
import com.adobe.acs.commons.wrap.jcr.BaseSessionIWrap;
import com.day.cq.search.PredicateGroup;
import com.day.cq.search.Query;
import com.day.cq.search.QueryBuilder;
import com.day.cq.search.facets.Bucket;
import com.day.cq.search.result.SearchResult;
import org.apache.jackrabbit.api.JackrabbitSession;
import org.apache.sling.api.resource.Resource;
import org.apache.sling.api.resource.ResourceResolver;
import org.apache.sling.testing.mock.sling.ResourceResolverType;
import org.apache.sling.testing.mock.sling.junit.SlingContext;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import org.mockito.runners.MockitoJUnitRunner;
@RunWith(MockitoJUnitRunner.class)
public class CloseableQueryBuilderImplTest {
@Rule
public SlingContext context = new SlingContext(ResourceResolverType.JCR_MOCK);
private ResourceResolver contextResolver;
@Mock
QueryBuilder mockQueryBuilder;
CloseableQueryBuilderImpl closeableQueryBuilder = new CloseableQueryBuilderImpl();
@Before
public void setUp() throws Exception {
MockitoAnnotations.initMocks(this);
context.registerService(QueryBuilder.class, mockQueryBuilder);
contextResolver = context.create().resource("/test").getResourceResolver();
contextResolver.commit();
context.registerInjectActivateService(closeableQueryBuilder);
}
@Test
public void testTryWithResources() throws Exception {
ResourceResolver hitResolver = context.resourceResolver().clone(null);
Resource hitResource = hitResolver.getResource("/test");
assertNotNull("hitResource getResourceResolver() should not be null",
hitResource.getResourceResolver());
assertNotSame("hitResource getResourceResolver() should not be same as context.resourceResolver()",
contextResolver, hitResource.getResourceResolver());
SearchResult mockSearchResult = mock(SearchResult.class);
Session mockSession = hitResolver.adaptTo(Session.class);
Query mockQuery = mock(Query.class);
when(mockSearchResult.getResources()).then((invocation) -> Collections.singletonList(hitResource).iterator());
when(mockQuery.getResult()).thenReturn(mockSearchResult);
when(mockQueryBuilder.createQuery(any(Session.class))).thenReturn(mockQuery);
assertTrue("hitResolver should be live", hitResolver.isLive());
try (CloseableQuery closeableQuery = closeableQueryBuilder.createQuery(mockSession)) {
/* should not throw exceptions */
assertTrue("resource resolver from first hit should be live",
closeableQuery.getResult().getResources().next().getResourceResolver().isLive());
}
assertFalse("hitResolver should not be live", hitResolver.isLive());
}
@Test
public void testCreateQuery() {
final JackrabbitSession mockJackrabbitSession = mock(JackrabbitSession.class);
final Session mockJcrSession = mock(Session.class);
final Query mockQuery = mock(Query.class);
when(mockQueryBuilder.createQuery(any(Session.class))).then((invocation) -> {
Session sessionArg = invocation.getArgumentAt(0, Session.class);
assertTrue("query session should be a wrapper: " + sessionArg.getClass().getName(),
sessionArg instanceof BaseSessionIWrap);
return mockQuery;
});
assertNotNull("returned query should not be null with resourceResolver",
closeableQueryBuilder.createQuery(contextResolver));
assertNotNull("returned query should not be null with mocked JCR session",
closeableQueryBuilder.createQuery(mockJcrSession));
assertNotNull("returned query should not be null with mocked Jackrabbit session",
closeableQueryBuilder.createQuery(mockJackrabbitSession));
final PredicateGroup predicates = new PredicateGroup();
when(mockQuery.getPredicates()).thenReturn(predicates);
when(mockQueryBuilder.createQuery(any(PredicateGroup.class), any(Session.class))).then((invocation) -> {
PredicateGroup predicatesArg = invocation.getArgumentAt(0, PredicateGroup.class);
assertSame("Same predicate group should be passed through", predicates, predicatesArg);
Session sessionArg = invocation.getArgumentAt(1, Session.class);
assertTrue("query session should be a wrapper: " + sessionArg.getClass().getName(),
sessionArg instanceof BaseSessionIWrap);
return mockQuery;
});
assertNotNull("returned query w/resolver and preds should not be null",
closeableQueryBuilder.createQuery(predicates, contextResolver));
assertSame("returned query w/resolver should have same preds", predicates,
closeableQueryBuilder.createQuery(predicates, contextResolver).getPredicates());
assertNotNull("returned query w/jcr and preds should not be null",
closeableQueryBuilder.createQuery(predicates, mockJcrSession));
assertSame("returned query w/jcr should have same preds", predicates,
closeableQueryBuilder.createQuery(predicates, mockJcrSession).getPredicates());
assertNotNull("returned query w/jackrabbit and preds should not be null",
closeableQueryBuilder.createQuery(predicates, mockJackrabbitSession));
assertSame("returned query w/jackrabbit should have same preds", predicates,
closeableQueryBuilder.createQuery(predicates, mockJackrabbitSession).getPredicates());
}
@Test
public void testLoadQuery() throws Exception {
final JackrabbitSession mockJackrabbitSession = mock(JackrabbitSession.class);
final Session mockJcrSession = mock(Session.class);
final Query mockQuery = mock(Query.class);
when(mockQueryBuilder.loadQuery(any(String.class), any(Session.class))).then((invocation) -> {
String pathArg = invocation.getArgumentAt(0, String.class);
Session sessionArg = invocation.getArgumentAt(1, Session.class);
assertTrue("query session should be a wrapper: " + sessionArg.getClass().getName(),
sessionArg instanceof BaseSessionIWrap);
if ("".equals(pathArg)) {
return null;
}
return mockQuery;
});
assertNotNull("load query should not be null with resourceResolver and path",
closeableQueryBuilder.loadQuery("/somepath", contextResolver));
assertNotNull("load query should not be null with mocked JCR session and path",
closeableQueryBuilder.loadQuery("/somepath", mockJcrSession));
assertNotNull("load query should not be null with mocked Jackrabbit session and path",
closeableQueryBuilder.loadQuery("/somepath", mockJackrabbitSession));
assertNull("load query should be null with resourceResolver and empty path",
closeableQueryBuilder.loadQuery("", contextResolver));
assertNull("load query should be null with mocked JCR session and empty path",
closeableQueryBuilder.loadQuery("", mockJcrSession));
assertNull("load query should be null with mocked Jackrabbit session and empty path",
closeableQueryBuilder.loadQuery("", mockJackrabbitSession));
}
@Test
public void testStoreQuery() throws Exception {
final JackrabbitSession mockJackrabbitSession = mock(JackrabbitSession.class);
final Session mockJcrSession = mock(Session.class);
final Query mockQuery = mock(Query.class);
doAnswer((invocation) -> {
Session sessionArg = invocation.getArgumentAt(3, Session.class);
assertTrue("query session should NOT be a session wrapper: " + sessionArg.getClass().getName(),
!(sessionArg instanceof BaseSessionIWrap));
return null;
}).when(mockQueryBuilder).storeQuery(isA(Query.class), isA(String.class), anyBoolean(), any(Session.class));
closeableQueryBuilder.storeQuery(mockQuery, "/somepath", true, contextResolver);
closeableQueryBuilder.storeQuery(mockQuery, "/somepath", true, mockJcrSession);
closeableQueryBuilder.storeQuery(mockQuery, "/somepath", true, mockJackrabbitSession);
verify(mockQueryBuilder, times(3))
.storeQuery(isA(Query.class), isA(String.class), anyBoolean(), any(Session.class));
}
@Test
public void testClearFacetCache() {
closeableQueryBuilder.clearFacetCache();
verify(mockQueryBuilder, times(1)).clearFacetCache();
}
@Test
public void testRefineQuery() {
final Query mockQuery = mock(Query.class);
final Bucket bucket = mock(Bucket.class);
final Query mockRefinedQuery = mock(Query.class);
when(mockQuery.refine(bucket)).thenReturn(mockRefinedQuery);
when(mockQueryBuilder.createQuery(any(Session.class))).thenReturn(mockQuery);
Query refinedQuery = closeableQueryBuilder.createQuery(contextResolver).refine(bucket);
assertNotSame("refined query should not be same as mock", refinedQuery, mockRefinedQuery);
assertTrue("refined query should also be wrapper: " + refinedQuery.getClass().getName(),
refinedQuery instanceof QueryIWrap);
}
@Test
public void testCloseableQueryImpl_wrapQuery() {
final Query mockQuery = mock(Query.class);
final CloseableQueryBuilderImpl.CloseableQueryImpl closeableQuery =
new CloseableQueryBuilderImpl.CloseableQueryImpl(mockQuery);
final Query mockOtherQuery = mock(Query.class);
final CloseableQueryBuilderImpl.CloseableQueryImpl closeableOtherQuery =
new CloseableQueryBuilderImpl.CloseableQueryImpl(mockOtherQuery);
final Query wrappedOther = closeableQuery.wrapQuery(mockOtherQuery);
assertNotSame("wrapped other should not be same as mock other", mockOtherQuery, wrappedOther);
final Query wrappedCloseableOther = closeableQuery.wrapQuery(closeableOtherQuery);
assertSame("wrapped closeable other should be same as closable other", closeableOtherQuery,
wrappedCloseableOther);
}
@Test
public void testGetAdapter() {
assertSame("getAdapter should return same instance with ResourceResolver and correct adapterType.",
closeableQueryBuilder, closeableQueryBuilder.getAdapter(contextResolver, CloseableQueryBuilder.class));
assertNull("getAdapter should return null for non-ResourceResolver adapter",
closeableQueryBuilder.getAdapter(context.request(), CloseableQueryBuilder.class));
assertNull("getAdapter should return null for incorrect adapterType",
closeableQueryBuilder.getAdapter(contextResolver, QueryBuilder.class));
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
You can’t perform that action at this time.