import java.io.IOException;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.List;

import javax.jcr.Node;
import javax.jcr.NodeIterator;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.query.Query;
import javax.jcr.query.QueryManager;
import javax.jcr.query.QueryResult;

import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.SlingHttpServletResponse;
import org.apache.sling.api.servlets.SlingSafeMethodsServlet;
import org.osgi.service.component.annotations.Component;

import com.google.gson.JsonArray;
import com.google.gson.JsonObject;

@Component(service = javax.servlet.Servlet.class, property = { "sling.servlet.paths=/bin/getpagedbypath" })
public class GetPagedByPathServlet extends SlingSafeMethodsServlet {

    @Override
    protected void doGet(SlingHttpServletRequest request, SlingHttpServletResponse response)
            throws IOException {
        try {
            // Get the JCR session
            Session session = request.getResourceResolver().adaptTo(Session.class);

            // Query statement
            String queryString = "SELECT page.* FROM [cq:Page] AS page "
                    + "INNER JOIN [cq:PageContent] AS jcrContentNode ON ISCHILDNODE(jcrContentNode, page) "
                    + "WHERE ISDESCENDANTNODE(page, '/content/we-retail') "
                    + "AND jcrContentNode.[cq:lastModified] <= CAST('2023-01-01T00:00:00.000+00:00' AS DATE)";

            // Create the query object
            QueryManager queryManager = session.getWorkspace().getQueryManager();
            Query query = queryManager.createQuery(queryString, Query.JCR_SQL2);

            // Execute the query
            QueryResult result = query.execute();

            // Get the nodes from the query result
            NodeIterator nodeIterator = result.getNodes();

            // Collect the paths of the first ten pages in a list
            List<String> pagePaths = new ArrayList<>();
            while (nodeIterator.hasNext()) {
                Node pageNode = nodeIterator.nextNode();
                String pagePath = pageNode.getPath();
                pagePaths.add(pagePath);
            }

            // Create a JSON object to hold the results
            JsonObject jsonResponse = new JsonObject();
            JsonArray resultsArray = new JsonArray();

            // Add the paths to the JSON array
            for (String path : pagePaths) {
                resultsArray.add(path);
            }

            // Add the JSON array to the response object
            jsonResponse.add("results", resultsArray);

            // Set the response content type
            response.setContentType("application/json");

            // Write the JSON response to the output
            PrintWriter writer = response.getWriter();
            writer.print(jsonResponse.toString());
            writer.flush();
        } catch (RepositoryException e) {
            // Handle exception
            response.setStatus(SlingHttpServletResponse.SC_INTERNAL_SERVER_ERROR);
            response.getWriter().println("Error executing query: " + e.getMessage());
        }
    }
}

import io.wcm.testing.mock.aem.junit5.AemContext;
import io.wcm.testing.mock.aem.junit5.AemContextExtension;
import org.apache.sling.api.SlingHttpServletRequest;
import org.apache.sling.api.SlingHttpServletResponse;
import org.apache.sling.api.resource.ResourceResolver;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;

import javax.jcr.NodeIterator;
import javax.jcr.RepositoryException;
import javax.jcr.Session;
import javax.jcr.Workspace;
import javax.jcr.query.Query;
import javax.jcr.query.QueryManager;
import javax.jcr.query.QueryResult;
import java.io.PrintWriter;
import java.io.StringWriter;

import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.mockito.Mockito.*;

@ExtendWith(AemContextExtension.class)
class GetPagedByPathServletTest {

    private final AemContext context = new AemContext();

    private GetPagedByPathServlet underTest = new GetPagedByPathServlet();

    @Mock
    private SlingHttpServletRequest request;

    @Mock
    private SlingHttpServletResponse response;

    @Mock
    private QueryManager queryManager;

    @Mock
    private Query query;

    @Mock
    private QueryResult queryResult;

    @Mock
    private Session session;

    @Mock
    private ResourceResolver resourceResolver;

    @Captor
    private ArgumentCaptor<String> queryCaptor;

    @Mock
    private PrintWriter printWriter;

    @BeforeEach
    void setUp() throws Exception {
        MockitoAnnotations.openMocks(this);
        context.registerService(QueryManager.class, queryManager);
        context.registerService(Query.class, query);
        context.registerService(QueryResult.class, queryResult);

        when(request.getResourceResolver()).thenReturn(resourceResolver);
        when(resourceResolver.adaptTo(Session.class)).thenReturn(session);
        Workspace workspace = mock(Workspace.class);
        when(session.getWorkspace()).thenReturn(workspace);
        when(workspace.getQueryManager()).thenReturn(queryManager);
        when(queryManager.createQuery(anyString(), eq(Query.JCR_SQL2))).thenReturn(query);
        when(query.execute()).thenReturn(queryResult);
        when(response.getWriter()).thenReturn(printWriter);
    }

    /**
     * In this test, we will only focus on the query string that is executed. This is a particularly
     * important step, because we would like to ensure that our query string is correct before
     * query.execute() is called.
     * @throws Exception
     */
    @Test
    void testDoGet_executedQuery() throws Exception {
        NodeIterator nodeIterator = mock(NodeIterator.class);
        when(queryResult.getNodes()).thenReturn(nodeIterator);
        underTest.doGet(request, response);

        // Verify that the correct query string was executed
        verify(query).execute();

        // Capture the argument passed to queryManager.createQuery
        verify(queryManager).createQuery(queryCaptor.capture(), eq(Query.JCR_SQL2));

        // Compare the captured query string with the expected query string
        String executedQueryString = queryCaptor.getValue();
        String expectedQueryString = "SELECT page.* FROM [cq:Page] AS page "
                + "INNER JOIN [cq:PageContent] AS jcrContentNode ON ISCHILDNODE(jcrContentNode, page) "
                + "WHERE ISDESCENDANTNODE(page, '/content/we-retail') "
                + "AND jcrContentNode.[cq:lastModified] <= CAST('2023-01-01T00:00:00.000+00:00' AS DATE)";

        assertEquals(expectedQueryString, executedQueryString);
    }

    /**
     * In this test, we are actually going to mock the response from query.execute() and verify
     * that the results has been processed, and the output of the servlet is correct. Here you
     * can see us mocking the NodeIterator, and then mocking the next node calls.
     * @throws Exception
     */
    @Test
    void testDoGet_successfulJsonResponse() throws Exception {
        NodeIterator nodeIterator = mock(NodeIterator.class);
        when(nodeIterator.hasNext()).thenReturn(true, true, false);
        when(nodeIterator.nextNode()).thenReturn(mock(javax.jcr.Node.class));
        when(nodeIterator.nextNode().getPath()).thenReturn("/content/we-retail/page1", "/content/we-retail/page2");
        when(queryResult.getNodes()).thenReturn(nodeIterator);
        underTest.doGet(request, response);
        String expectedOutput = "{"results":["/content/we-retail/page1","/content/we-retail/page2"]}";
        printWriter.print(expectedOutput);
    }

    /**
     * In this test, we are going to test a server error, for example a failure for query.execute(),
     * and verify that the response status is set to 500, and the error message is printed.
     * @throws Exception
     */
    @Test
    void testDoGet_serverError() throws Exception {
        when(queryManager.createQuery(anyString(), eq(Query.JCR_SQL2))).thenReturn(query);
        when(query.execute()).thenThrow(new RepositoryException("Test exception"));

        StringWriter stringWriter = new StringWriter();
        PrintWriter printWriter = new PrintWriter(stringWriter);
        when(response.getWriter()).thenReturn(printWriter);

        underTest.doGet(request, response);

        // Verify that the response status is set to 500
        verify(response).setStatus(SlingHttpServletResponse.SC_INTERNAL_SERVER_ERROR);

        // Verify that the error message is printed
        String expectedErrorMessage = "Error executing query: Test exception\n";
        assertEquals(expectedErrorMessage, stringWriter.toString());
    }
}