alfresco-community-repo/source/test-java/org/alfresco/repo/virtual/template/VirtualQueryImplTest.java

package org.alfresco.repo.virtual.template;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

import junit.framework.TestCase;

import org.alfresco.repo.search.EmptyResultSet;
import org.alfresco.repo.virtual.ActualEnvironment;
import org.alfresco.repo.virtual.ref.Protocols;
import org.alfresco.repo.virtual.ref.Reference;
import org.alfresco.repo.virtual.ref.VirtualProtocol;
import org.alfresco.service.cmr.repository.NodeRef;
import org.alfresco.service.cmr.repository.StoreRef;
import org.alfresco.service.cmr.search.SearchParameters;
import org.alfresco.service.cmr.search.SearchParameters.SortDefinition;
import org.alfresco.service.cmr.search.SearchService;
import org.alfresco.service.namespace.NamespacePrefixResolver;
import org.alfresco.service.namespace.QName;
import org.alfresco.util.Pair;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.Mockito;

public class VirtualQueryImplTest extends TestCase
{

    private static final String QUERY_TEST_STRING_QUERY = "QUERY_TEST_STRING_QUERY";

    private static final String TEST_LOCAL_NAME_1 = "testQName1";

    private static final String TEST_LOCAL_NAME_2 = "testQName2";

    private static final String TEST_URI = "http://test/uri";

    private static final String TST_PREFIX = "tst";

    private VirtualQueryImpl query;

    private ActualEnvironment mockitoActualEnvironment;

    private NamespacePrefixResolver mockitoPrefixResolver;

    private QName testQName1;

    private QName testQName2;

    private Reference nodeOneReference;

    @Override
    protected void setUp() throws Exception
    {
        super.setUp();

        query = new VirtualQueryImpl(StoreRef.STORE_REF_WORKSPACE_SPACESSTORE.toString(),
                                     SearchService.LANGUAGE_FTS_ALFRESCO,
                                     QUERY_TEST_STRING_QUERY);

        mockitoActualEnvironment = Mockito.mock(ActualEnvironment.class);
        Mockito.when(mockitoActualEnvironment.query(Mockito.any(SearchParameters.class)))
                        .thenReturn(new EmptyResultSet());

        mockitoPrefixResolver = Mockito.mock(NamespacePrefixResolver.class);
        Mockito.when(mockitoPrefixResolver.getNamespaceURI(TST_PREFIX)).thenReturn(TEST_URI);
        Mockito.when(mockitoPrefixResolver.getPrefixes(TEST_URI)).thenReturn(Arrays.asList(TST_PREFIX));

        Mockito.when(mockitoActualEnvironment.getNamespacePrefixResolver()).thenReturn(mockitoPrefixResolver);

        testQName1 = QName.createQName(TST_PREFIX,
                                       TEST_LOCAL_NAME_1,
                                       mockitoPrefixResolver);

        testQName2 = QName.createQName(TST_PREFIX,
                                       TEST_LOCAL_NAME_2,
                                       mockitoPrefixResolver);

        NodeRef n1 = new NodeRef("workspace://SpacesStore/17c8f11d-0936-4295-88a0-12b85764c76f");
        NodeRef n2 = new NodeRef("workspace://SpacesStore/27c8f11d-0936-4295-88a0-12b85764c76f");
        nodeOneReference = ((VirtualProtocol) Protocols.VIRTUAL.protocol).newReference(n1,
                                                                                       "/1",
                                                                                       n2);
    }

    @Test
    public void testPerform_1() throws Exception
    {
        Pair<QName, Boolean> withSortDefinitions = new Pair<QName, Boolean>(testQName2,
                                                                            true);

        VirtualQueryConstraint constraint = BasicConstraint.INSTANCE;
        constraint = new FilesFoldersConstraint(constraint,
                                                true,
                                                true);
        constraint = new IgnoreConstraint(constraint,
                                          Collections.singleton(testQName2),
                                                 Collections.singleton(testQName1));
        constraint = new SortConstraint(constraint,
                                        Arrays.asList(withSortDefinitions));

        query.perform(mockitoActualEnvironment,
                      constraint,
                      null,
                      nodeOneReference);

        assertPerform1Results(withSortDefinitions);
    }

    public void testPerform_2() throws Exception
    {

        VirtualQueryConstraint constraint = BasicConstraint.INSTANCE;
        constraint = new FilesFoldersConstraint(constraint,
                                                false,
                                                true);
        constraint = new IgnoreConstraint(constraint,
                                          Collections.singleton(testQName2),
                                                 Collections.singleton(testQName1));

        query.perform(mockitoActualEnvironment,
                      constraint,
                      null,
                      nodeOneReference);

        assertPerform2Results();
    }

    private void assertPerform1Results(Pair<QName, Boolean> withSortDefinitions)
    {
        ArgumentCaptor<SearchParameters> queryCaptor = ArgumentCaptor.forClass(SearchParameters.class);
        Mockito.verify(mockitoActualEnvironment).query(queryCaptor.capture());

        assertEquals("(QUERY_TEST_STRING_QUERY) and !ASPECT:'tst:testQName1' and !TYPE:'tst:testQName2'",
                     queryCaptor.getValue().getQuery());

        ArrayList<SortDefinition> sortDefinitions = queryCaptor.getValue().getSortDefinitions();

        assertNotNull(sortDefinitions);
        assertEquals(1,
                     sortDefinitions.size());
        assertEquals(withSortDefinitions.getFirst().getLocalName(),
                     sortDefinitions.get(0).getField());

        assertEquals(withSortDefinitions.getSecond(),
                     Boolean.valueOf(sortDefinitions.get(0).isAscending()));
    }

    @Test
    public void testPerform_deprecated_1() throws Exception
    {
        Pair<QName, Boolean> withSortDefinitions = new Pair<QName, Boolean>(testQName2,
                                                                            true);
        query.perform(mockitoActualEnvironment,
                      true,
                      true,
                      null,
                      Collections.singleton(testQName2),
                      Collections.<QName> emptySet(),
                      Collections.singleton(testQName1),
                      Arrays.asList(withSortDefinitions),
                      null,
                      nodeOneReference);

        assertPerform1Results(withSortDefinitions);
    }

    @Test
    public void testPerform_deprecated_2() throws Exception
    {
        query.perform(mockitoActualEnvironment,
                      false,
                      true,
                      null,
                      Collections.singleton(testQName2),
                      Collections.<QName> emptySet(),
                      Collections.singleton(testQName1),
                      Collections.<Pair<QName, Boolean>> emptyList(),
                      null,
                      nodeOneReference);

        assertPerform2Results();

    }

    private void assertPerform2Results()
    {
        ArgumentCaptor<SearchParameters> queryCaptor = ArgumentCaptor.forClass(SearchParameters.class);
        Mockito.verify(mockitoActualEnvironment).query(queryCaptor.capture());

        assertEquals("((QUERY_TEST_STRING_QUERY) and TYPE:\"cm:folder\") and !ASPECT:'tst:testQName1' and !TYPE:'tst:testQName2'",
                     queryCaptor.getValue().getQuery());

        ArrayList<SortDefinition> sortDefinitions = queryCaptor.getValue().getSortDefinitions();

        assertNotNull(sortDefinitions);
        assertEquals(0,
                     sortDefinitions.size());
    }
}