// This test has set response to JSON and pass StringHandle with format as JSON, expectint it to
  // work, logged an issue 82
  @Test
  public void testBulkSearchSQDwithResponseFormatandStringHandle() throws Exception {
    loadJSONDocuments();
    JSONDocumentManager docMgr = client.newJSONDocumentManager();

    QueryManager queryMgr = client.newQueryManager();
    StructuredQueryBuilder qb = new StructuredQueryBuilder();
    StructuredQueryDefinition qd = qb.and(qb.term("dog1", "dog11"));
    queryMgr.search(qd, new SearchHandle());

    docMgr.setNonDocumentFormat(Format.JSON);
    docMgr.setSearchView(QueryView.METADATA);
    docMgr.setMetadataCategories(Metadata.PERMISSIONS);

    StringHandle results = new StringHandle().withFormat(Format.JSON);
    DocumentPage page = docMgr.search(qd, 1, results);
    DocumentMetadataHandle mh = new DocumentMetadataHandle();
    while (page.hasNext()) {
      DocumentRecord rec = page.next();
      validateRecord(rec, Format.JSON);
      docMgr.readMetadata(rec.getUri(), mh);
      assertTrue("Records has permissions? ", mh.getPermissions().containsKey("flexrep-eval"));
      assertTrue("Record has collections ?", mh.getCollections().isEmpty());
    }
    assertFalse("Search handle contains", results.get().isEmpty());
  }
  @Test
  public void testPOJOSearchWithoutSearchHandle() {
    PojoRepository<Artifact, Long> products = client.newPojoRepository(Artifact.class, Long.class);
    PojoPage<Artifact> p;
    this.loadSimplePojos(products);
    QueryManager queryMgr = client.newQueryManager();
    StringQueryDefinition qd = queryMgr.newStringDefinition();
    qd.setCriteria("Widgets");

    products.setPageLength(11);
    p = products.search(qd, 1);
    assertEquals("total no of pages", 5, p.getTotalPages());
    System.out.println(p.getTotalPages());
    long pageNo = 1, count = 0;
    do {
      count = 0;

      p = products.search(qd, pageNo);

      while (p.iterator().hasNext()) {
        Artifact a = p.iterator().next();
        validateArtifact(a);
        assertTrue("Artifact Id is odd", a.getId() % 2 != 0);
        assertTrue(
            "Company name contains widgets", a.getManufacturer().getName().contains("Widgets"));
        count++;
        //				System.out.println(a.getId()+" "+a.getManufacturer().getName() +"  "+count);
      }
      assertEquals("Page size", count, p.size());
      pageNo = pageNo + p.getPageSize();
    } while (!p.isLastPage() && pageNo < p.getTotalSize());
    assertEquals("page number after the loop", 5, p.getPageNumber());
    assertEquals("total no of pages", 5, p.getTotalPages());
  }
 @Override
 public void deleteAll(Transaction transaction) {
   QueryManager queryMgr = client.newQueryManager();
   DeleteQueryDefinition deleteQuery = queryMgr.newDeleteDefinition();
   deleteQuery.setCollections(entityClass.getName());
   queryMgr.delete(deleteQuery, transaction);
 }
  @Test(expected = ClassCastException.class)
  public void testPOJOqbeSearchWithSearchHandle() {
    PojoRepository<Artifact, Long> products = client.newPojoRepository(Artifact.class, Long.class);
    PojoPage<Artifact> p;
    this.loadSimplePojos(products);

    QueryManager queryMgr = client.newQueryManager();
    String queryAsString =
        "{\"$query\":{"
            + "\"$and\":[{\"inventory\":{\"$gt\":1010}},{\"inventory\":{\"$le\":1110}}]"
            + ",\"$filtered\": true}}";
    System.out.println(queryAsString);
    PojoQueryDefinition qd =
        (PojoQueryDefinition)
            queryMgr.newRawQueryByExampleDefinition(
                new StringHandle(queryAsString).withFormat(Format.JSON));
    qd.setCollections("even");
    SearchHandle results = new SearchHandle();
    products.setPageLength(10);
    p = products.search(qd, 1, results);
    assertEquals("total no of pages", 5, p.getTotalPages());
    System.out.println(p.getTotalPages());
    //		System.out.println(results.getMetrics().getQueryResolutionTime());
    long pageNo = 1, count = 0;
    do {
      count = 0;
      p = products.search(qd, pageNo, results);

      while (p.iterator().hasNext()) {
        Artifact a = p.iterator().next();
        validateArtifact(a);
        assertTrue(
            "Enventory lies between 1010 to 1110",
            a.getInventory() > 1010 && a.getInventory() <= 1110);
        assertTrue("Artifact Id is even", a.getId() % 2 == 0);
        assertTrue("Company name contains Acme", a.getManufacturer().getName().contains("Acme"));
        count++;
        //				System.out.println(a.getId()+" "+a.getManufacturer().getName() +"  "+count);
      }
      assertEquals("Page size", count, p.size());
      pageNo = pageNo + p.getPageSize();
      MatchDocumentSummary[] mds = results.getMatchResults();
      assertEquals("Size of the results summary", 10, mds.length);
      for (MatchDocumentSummary md : mds) {
        assertTrue("every uri should contain the class name", md.getUri().contains("Artifact"));
      }
      String[] facetNames = results.getFacetNames();
      for (String fname : facetNames) {
        System.out.println(fname);
      }
      //			assertEquals("Total results from search handle ",50,results.getTotalResults());
      //			assertTrue("Search Handle metric results ",results.getMetrics().getTotalTime()>0);
    } while (!p.isLastPage() && pageNo < p.getTotalSize());
    assertEquals("Page start check", 41, p.getStart());
    assertEquals("page number after the loop", 5, p.getPageNumber());
    assertEquals("total no of pages", 5, p.getTotalPages());
  }
  @Test(expected = ClassCastException.class)
  public void testPOJOCombinedSearchWithJacksonHandle() {
    PojoRepository<Artifact, Long> products = client.newPojoRepository(Artifact.class, Long.class);
    PojoPage<Artifact> p;
    this.loadSimplePojos(products);
    QueryManager queryMgr = client.newQueryManager();
    String queryAsString =
        "{\"search\":{\"query\":{\"and-query\":["
            + "{\"word-constraint-query\":{\"constraint-name\":\"pojo-name-field\", \"text\":\"Acme\"}},"
            + "{\"word-constraint-query\":{\"constraint-name\":\"pojo-name-field\", \"text\":\"special\"}}]},"
            + "\"options\":{\"constraint\":{\"name\":\"pojo-name-field\", \"word\":{\"json-property\":\"name\"}}}"
            + "}}";

    PojoQueryDefinition qd =
        (PojoQueryDefinition)
            queryMgr.newRawCombinedQueryDefinition(
                new StringHandle(queryAsString).withFormat(Format.JSON));
    JacksonHandle results = new JacksonHandle();
    p = products.search(qd, 1, results);
    products.setPageLength(11);
    assertEquals("total no of pages", 1, p.getTotalPages());
    //		System.out.println(p.getTotalPages()+results.get().toString());
    long pageNo = 1, count = 0;
    do {
      count = 0;
      p = products.search(qd, pageNo, results);

      while (p.iterator().hasNext()) {
        Artifact a = p.iterator().next();
        validateArtifact(a);
        count++;
        assertTrue(
            "Manufacture name starts with acme", a.getManufacturer().getName().contains("Acme"));
        assertTrue("Artifact name contains", a.getName().contains("special"));
      }
      assertEquals("Page size", count, p.size());
      pageNo = pageNo + p.getPageSize();

      assertEquals(
          "Page start from search handls vs page methods",
          results.get().get("start").asLong(),
          p.getStart());
      assertEquals(
          "Format in the search handle",
          "json",
          results.get().withArray("results").get(1).path("format").asText());
      assertTrue(
          "Uri in search handle contains Artifact",
          results.get().withArray("results").get(1).path("uri").asText().contains("Artifact"));
      //			System.out.println(results.get().toString());
    } while (!p.isLastPage() && pageNo < p.getTotalSize());
    assertFalse("search handle has metrics", results.get().has("metrics"));
    assertEquals("Total from search handle", 11, results.get().get("total").asInt());
    assertEquals("page number after the loop", 1, p.getPageNumber());
    assertEquals("total no of pages", 1, p.getTotalPages());
  }
  @Test
  public void testFailedSearch() throws IOException {
    QueryManager queryMgr = Common.client.newQueryManager();
    StructuredQueryBuilder qb = queryMgr.newStructuredQueryBuilder();
    StructuredQueryDefinition qdef = qb.term("criteriaThatShouldNotMatchAnyDocument");

    SearchHandle results = queryMgr.search(qdef, new SearchHandle());
    assertNotNull(results);

    MatchDocumentSummary[] summaries = results.getMatchResults();
    assertTrue(summaries == null || summaries.length == 0);
  }
 // This test is to verify extract-document-data & extract-path with  selected=exclude option query
 @Test
 public void testExtractDocumentData2() throws Exception {
   this.loadJSONDocuments();
   this.loadXMLDocuments();
   String head = "<search:search xmlns:search=\"http://marklogic.com/appservices/search\">";
   String tail = "</search:search>";
   String qtext4 = "<search:qtext>71 OR dog14</search:qtext>";
   DocumentManager docMgr = client.newDocumentManager();
   QueryManager queryMgr = client.newQueryManager();
   String options =
       "<search:options>"
           + "<search:extract-document-data selected=\"exclude\">"
           + "<search:extract-path>//foo</search:extract-path>"
           + "<search:extract-path>//says</search:extract-path>"
           + "</search:extract-document-data>"
           + "</search:options>";
   // test XML response with extracted XML and JSON matches
   String combinedSearch = head + qtext4 + options + tail;
   RawCombinedQueryDefinition rawCombinedQueryDefinition =
       queryMgr.newRawCombinedQueryDefinition(
           new StringHandle(combinedSearch).withMimetype("application/xml"));
   SearchHandle results = queryMgr.search(rawCombinedQueryDefinition, new SearchHandle());
   MatchDocumentSummary[] summaries = results.getMatchResults();
   assertNotNull(summaries);
   assertEquals(2, summaries.length);
   for (MatchDocumentSummary summary : summaries) {
     ExtractedResult extracted = summary.getExtracted();
     if (Format.XML == summary.getFormat()) {
       // we don't test for kind because it isn't sent in this case
       System.out.println("EXTRACTED Size ==" + extracted.size());
       // TODO:: Bug 33921 also add test to include-with-ancestors
       assertEquals(0, extracted.size());
       //			Document item1 = extracted.next().getAs(Document.class);
       //			assertEquals("This is so foo with a bar 71", item1.getFirstChild().getTextContent());
       continue;
     } else if (Format.JSON == summary.getFormat()) {
       // we don't test for kind because it isn't sent in this case
       assertEquals(1, extracted.size());
       for (ExtractedItem item : extracted) {
         String stringJsonItem = item.getAs(String.class);
         JsonNode nodeJsonItem = item.getAs(JsonNode.class);
         if (nodeJsonItem.has("animal")) {
           assertEquals("{\"animal\":\"dog14\"}", stringJsonItem);
           continue;
         }
         fail("unexpected extracted item:" + stringJsonItem);
       }
       continue;
     }
     fail("unexpected search result:" + summary.getUri());
   }
 }
  // This test is to verify RAW XML structured Query
  @Test
  public void testBulkSearchRawXMLStrucQD() throws Exception {
    //		setAutomaticDirectoryCreation(dbName,"automatic");
    setMaintainLastModified(dbName, true);
    this.loadJSONDocuments();
    this.loadXMLDocuments();
    GenericDocumentManager docMgr = client.newDocumentManager();
    QueryManager queryMgr = client.newQueryManager();
    String rawXMLQuery =
        "<search:query "
            + "xmlns:search='http://marklogic.com/appservices/search'>"
            + " <search:or-query><search:term-query>"
            + "<search:text>bar</search:text>"
            + "</search:term-query>"
            + "<search:term-query>"
            + "<search:text>woof</search:text>"
            + "</search:term-query> </search:or-query>"
            + "</search:query>";
    StringHandle rh = new StringHandle(rawXMLQuery);
    RawStructuredQueryDefinition qd = queryMgr.newRawStructuredQueryDefinition(rh);
    DOMHandle dh = new DOMHandle();
    DocumentPage page = docMgr.search(qd, 1, dh);
    DocumentMetadataHandle mh = new DocumentMetadataHandle();

    int count = 1;
    while (count < 4) {
      page = docMgr.search(qd, count, dh);

      while (page.hasNext()) {
        DocumentRecord rec = page.next();
        if (rec.getMimetype().contains("xml")) {
          validateRecord(rec, Format.XML);
        } else {
          validateRecord(rec, Format.JSON);
        }
        docMgr.readMetadata(rec.getUri(), mh);
        assertTrue("Records has permissions? ", mh.getPermissions().containsKey("flexrep-eval"));
        assertFalse("Record has collections ?", mh.getCollections().isEmpty());
      }
      System.out.println(this.convertXMLDocumentToString(dh.get()));
      assertEquals(
          "Total search results before transaction rollback are ",
          "204",
          dh.get()
              .getElementsByTagNameNS("*", "response")
              .item(0)
              .getAttributes()
              .getNamedItem("total")
              .getNodeValue());
      count++;
    }
  }
  @Test
  public void testJSON() {
    QueryManager queryMgr = Common.client.newQueryManager();
    StructuredQueryBuilder qb = queryMgr.newStructuredQueryBuilder();
    StructuredQueryDefinition t = qb.term("leaf3");

    // create a handle for the search results
    StringHandle resultsHandle = new StringHandle().withFormat(Format.JSON);

    // run the search
    queryMgr.search(t, resultsHandle);

    assertEquals("{", resultsHandle.get().substring(0, 1)); // It's JSON, right?
  }
  // This test is testing SearchView options and search handle
  @Test
  public void testBulkSearchSQDwithJSONResponseFormat() throws Exception {

    loadJSONDocuments();
    JSONDocumentManager docMgr = client.newJSONDocumentManager();

    QueryManager queryMgr = client.newQueryManager();
    StructuredQueryBuilder qb = new StructuredQueryBuilder();
    StructuredQueryDefinition qd = qb.and(qb.term("woof"));
    docMgr.setNonDocumentFormat(Format.JSON);

    docMgr.setSearchView(QueryView.FACETS);
    JacksonHandle jh = new JacksonHandle();
    docMgr.search(qd, 1, jh);

    //		System.out.println(jh.get().toString());
    assertTrue("Searh response has entry for facets", jh.get().has("facets"));
    assertFalse(
        "Searh response has entry for facets",
        jh.get().has("results")); // Issue 84 is tracking this
    assertFalse("Searh response has entry for facets", jh.get().has("metrics"));

    docMgr.setSearchView(QueryView.RESULTS);
    docMgr.search(qd, 1, jh);

    assertFalse("Searh response has entry for facets", jh.get().has("facets"));
    assertTrue("Searh response has entry for facets", jh.get().has("results"));
    assertFalse(
        "Searh response has entry for facets",
        jh.get().has("metrics")); // Issue 84 is tracking this

    docMgr.setSearchView(QueryView.METADATA);
    docMgr.search(qd, 1, jh);

    assertFalse("Searh response has entry for facets", jh.get().has("facets"));
    assertFalse("Searh response has entry for facets", jh.get().has("results"));
    assertTrue("Searh response has entry for facets", jh.get().has("metrics"));

    docMgr.setSearchView(QueryView.ALL);
    docMgr.search(qd, 1, jh);

    assertTrue("Searh response has entry for facets", jh.get().has("facets"));
    assertTrue("Searh response has entry for facets", jh.get().has("results"));
    assertTrue("Searh response has entry for facets", jh.get().has("metrics"));

    queryMgr.setView(QueryView.FACETS);
    queryMgr.search(qd, jh);
    System.out.println(jh.get().toString());
  }
  @Test
  public void testStructuredSearch1() throws IOException {
    QueryManager queryMgr = Common.client.newQueryManager();
    StructuredQueryBuilder qb = queryMgr.newStructuredQueryBuilder();

    for (QueryDefinition t :
        new QueryDefinition[] {qb.term("leaf3"), qb.build(qb.value(qb.element("leaf"), "leaf3"))}) {

      MatchDocumentSummary summary = queryMgr.findOne(t);
      assertNotNull(summary);

      GenericDocumentManager docMgr = Common.client.newDocumentManager();
      assertNotNull("Document exists", docMgr.exists(summary.getUri()));
    }
  }
  @Test
  public void testPOJOSearchWithJacksonHandle() {
    PojoRepository<Artifact, Long> products = client.newPojoRepository(Artifact.class, Long.class);
    PojoPage<Artifact> p;
    this.loadSimplePojos(products);
    QueryManager queryMgr = client.newQueryManager();
    StringQueryDefinition qd = queryMgr.newStringDefinition();
    qd.setCriteria("cogs");
    JacksonHandle results = new JacksonHandle();
    p = products.search(qd, 1, results);
    products.setPageLength(11);
    assertEquals("total no of pages", 3, p.getTotalPages());
    //		System.out.println(p.getTotalPages()+results.get().toString());
    long pageNo = 1, count = 0;
    do {
      count = 0;
      p = products.search(qd, pageNo, results);

      while (p.iterator().hasNext()) {
        Artifact a = p.iterator().next();
        validateArtifact(a);
        count++;
        //				System.out.println(a.getId()+" "+a.getManufacturer().getName() +"  "+count);
      }
      assertEquals("Page size", count, p.size());
      pageNo = pageNo + p.getPageSize();

      assertEquals(
          "Page start from search handls vs page methods",
          results.get().get("start").asLong(),
          p.getStart());
      assertEquals(
          "Format in the search handle",
          "json",
          results.get().withArray("results").get(1).path("format").asText());
      assertTrue(
          "Uri in search handle contains Artifact",
          results.get().withArray("results").get(1).path("uri").asText().contains("Artifact"));
      //			System.out.println(results.get().toString());
    } while (!p.isLastPage() && pageNo < p.getTotalSize());
    //		assertTrue("search handle has metrics",results.get().has("metrics"));
    assertEquals("Search text is", "cogs", results.get().path("qtext").asText());
    assertEquals("Total from search handle", 110, results.get().get("total").asInt());
    assertEquals("page number after the loop", 10, p.getPageNumber());
    assertEquals("total no of pages", 10, p.getTotalPages());
  }
  @Test
  public void testExtractMetadata() throws SAXException, IOException {
    QueryManager queryMgr = Common.client.newQueryManager();

    String combined =
        "<search xmlns=\"http://marklogic.com/appservices/search\">"
            + "<query>"
            + "<value-query>"
            + "<element ns=\"http://marklogic.com/xdmp/json\" name=\"firstKey\"/>"
            + "<text>first value</text>"
            + "</value-query>"
            + "</query>"
            + "<options>"
            + "<extract-metadata>"
            + "<qname elem-ns=\"http://marklogic.com/xdmp/json\" elem-name=\"subKey\"/>"
            + "</extract-metadata>"
            + "</options>"
            + "</search>";
    StringHandle rawHandle = new StringHandle(combined);

    RawCombinedQueryDefinition rawDef = queryMgr.newRawCombinedQueryDefinition(rawHandle);

    SearchHandle sh = queryMgr.search(rawDef, new SearchHandle());

    MatchDocumentSummary[] summaries = sh.getMatchResults();
    assertNotNull(summaries);
    assertEquals("expected 1 result", 1, summaries.length);

    MatchDocumentSummary matchResult = summaries[0];
    Document metadata = matchResult.getMetadata();
    Element subKey =
        (Element)
            metadata.getElementsByTagNameNS("http://marklogic.com/xdmp/json", "subKey").item(0);
    assertEquals("string", subKey.getAttribute("type"));
    assertEquals("sub value", subKey.getTextContent());

    String docStr = Common.testDocumentToString(metadata);
    String handleStr = matchResult.getMetadata(new StringHandle()).get();
    assertXMLEqual("Different metadata for handle", docStr, handleStr);

    Document snippet = matchResult.getSnippets()[0];
    docStr = Common.testDocumentToString(snippet);
    handleStr = matchResult.getSnippetIterator(new StringHandle()).next().get();
    assertXMLEqual("Different snippet for handle", docStr, handleStr);
  }
  @Test
  public void testStructuredSearch2() throws IOException {
    QueryManager queryMgr = Common.client.newQueryManager();

    EditableNamespaceContext namespaces = new EditableNamespaceContext();
    namespaces.put("x", "root.org");
    namespaces.put("y", "target.org");
    StructuredQueryBuilder qb = new StructuredQueryBuilder(namespaces);

    StructuredQueryDefinition qdef =
        qb.geospatial(qb.geoPath(qb.pathIndex("/x:geo/y:path")), qb.box(1, 2, 3, 4));

    SearchHandle results = queryMgr.search(qdef, new SearchHandle());
    assertNotNull(results);

    MatchDocumentSummary[] summaries = results.getMatchResults();
    assertTrue(summaries == null || summaries.length == 0);
  }
  @Test
  public void testPOJOSearchWithSearchHandle() {
    PojoRepository<Artifact, Long> products = client.newPojoRepository(Artifact.class, Long.class);
    PojoPage<Artifact> p;
    this.loadSimplePojos(products);
    QueryManager queryMgr = client.newQueryManager();
    StringQueryDefinition qd = queryMgr.newStringDefinition();
    qd.setCriteria("Acme");
    SearchHandle results = new SearchHandle();
    products.setPageLength(11);
    p = products.search(qd, 1, results);
    assertEquals("total no of pages", 5, p.getTotalPages());
    System.out.println(p.getTotalPages());
    long pageNo = 1, count = 0;
    do {
      count = 0;
      p = products.search(qd, pageNo, results);

      while (p.iterator().hasNext()) {
        Artifact a = p.iterator().next();
        validateArtifact(a);
        assertTrue("Artifact Id is even", a.getId() % 2 == 0);
        assertTrue("Company name contains Acme", a.getManufacturer().getName().contains("Acme"));
        count++;
        //				System.out.println(a.getId()+" "+a.getManufacturer().getName() +"  "+count);
      }
      assertEquals("Page size", count, p.size());
      pageNo = pageNo + p.getPageSize();
      MatchDocumentSummary[] mds = results.getMatchResults();
      assertEquals("Size of the results summary", 11, mds.length);
      for (MatchDocumentSummary md : mds) {
        assertTrue("every uri should contain the class name", md.getUri().contains("Artifact"));
      }
      String[] facetNames = results.getFacetNames();
      for (String fname : facetNames) {
        System.out.println(fname);
      }
      assertEquals("Total resulr from search handle ", 55, results.getTotalResults());
      //			assertTrue("Search Handle metric results ",results.getMetrics().getTotalTime()>0);
    } while (!p.isLastPage() && pageNo < p.getTotalSize());
    assertEquals("Page start check", 45, p.getStart());
    assertEquals("page number after the loop", 5, p.getPageNumber());
    assertEquals("total no of pages", 5, p.getTotalPages());
  }
  // Searching for Id as Number in JSON using range query
  @Test(expected = ClassCastException.class)
  public void testPOJOcombinedSearchforNumberWithStringHandle()
      throws JsonProcessingException, IOException {
    PojoRepository<Artifact, Long> products = client.newPojoRepository(Artifact.class, Long.class);
    PojoPage<Artifact> p;
    this.loadSimplePojos(products);

    QueryManager queryMgr = client.newQueryManager();
    String queryAsString =
        "{\"search\":{\"query\":{"
            + "\"range-constraint-query\":{\"constraint-name\":\"id\", \"value\":[5,10,15,20,25,30]}},"
            + "\"options\":{\"return-metrics\":false, \"constraint\":{\"name\":\"id\", \"range\":{\"type\": \"xs:long\",\"json-property\":\"id\"}}}"
            + "}}";
    PojoQueryDefinition qd =
        (PojoQueryDefinition)
            queryMgr.newRawCombinedQueryDefinition(
                new StringHandle(queryAsString).withFormat(Format.JSON));

    StringHandle results = new StringHandle();
    JacksonHandle jh = new JacksonHandle();
    p = products.search(qd, 1, jh);

    long pageNo = 1, count = 0;
    do {
      count = 0;
      p = products.search(qd, pageNo, results.withFormat(Format.JSON));

      while (p.iterator().hasNext()) {
        Artifact a = p.iterator().next();
        validateArtifact(a);
        count++;
      }
      assertEquals("Page total results", count, p.getTotalSize());
      pageNo = pageNo + p.getPageSize();
      System.out.println(results.get().toString());
    } while (!p.isLastPage() && pageNo < p.getTotalSize());
    assertFalse("String handle is not empty", results.get().isEmpty());
    assertTrue("String handle contains results", results.get().contains("results"));
    assertTrue("String handle contains format", results.get().contains("\"format\":\"json\""));
    ObjectMapper mapper = new ObjectMapper();
    JsonNode actNode = mapper.readTree(results.get()).get("total");
    assertEquals("Total search results resulted are ", 6, actNode.asInt());
  }
  @Test(expected = ClassCastException.class)
  public void testPOJOqbeSearchWithoutSearchHandle() {
    PojoRepository<Artifact, Long> products = client.newPojoRepository(Artifact.class, Long.class);
    PojoPage<Artifact> p;
    this.loadSimplePojos(products);
    QueryManager queryMgr = client.newQueryManager();
    String queryAsString =
        "{\"$query\":{"
            + "\"$and\":[{\"name\":{\"$word\":\"cogs\",\"$exact\": false}}]"
            + ",\"$not\":[{\"name\":{\"$word\":\"special\",\"$exact\": false}}]"
            + "}}";

    PojoQueryDefinition qd =
        (PojoQueryDefinition)
            queryMgr.newRawQueryByExampleDefinition(
                new StringHandle(queryAsString).withFormat(Format.JSON));
    qd.setCollections("odd");
    products.setPageLength(11);
    p = products.search(qd, 1);
    assertEquals("total no of pages", 4, p.getTotalPages());
    //		System.out.println(p.getTotalPages());
    long pageNo = 1, count = 0;
    do {
      count = 0;

      p = products.search(qd, pageNo);

      while (p.iterator().hasNext()) {
        Artifact a = p.iterator().next();
        validateArtifact(a);
        assertFalse("Verifying document with special is not there", a.getId() % 5 == 0);
        assertTrue("Artifact Id is odd", a.getId() % 2 != 0);
        assertTrue(
            "Company name contains widgets", a.getManufacturer().getName().contains("Widgets"));
        count++;
        //				System.out.println(a.getId()+" "+a.getManufacturer().getName() +"  "+count);
      }
      assertEquals("Page size", count, p.size());
      pageNo = pageNo + p.getPageSize();
    } while (!p.isLastPage() && pageNo < p.getTotalSize());
    assertEquals("page number after the loop", 4, p.getPageNumber());
    assertEquals("total no of pages", 4, p.getTotalPages());
  }
  // Searching for Id as Number in JSON using string should not return any results
  @Test
  public void testPOJOSearchWithStringHandle() throws JsonProcessingException, IOException {
    PojoRepository<Artifact, Long> products = client.newPojoRepository(Artifact.class, Long.class);
    PojoPage<Artifact> p;
    this.loadSimplePojos(products);
    QueryManager queryMgr = client.newQueryManager();
    StringQueryDefinition qd = queryMgr.newStringDefinition();
    qd.setCriteria("5");
    StringHandle results = new StringHandle();
    JacksonHandle jh = new JacksonHandle();
    p = products.search(qd, 1, jh);

    long pageNo = 1, count = 0;
    do {
      count = 0;
      p = products.search(qd, pageNo, results.withFormat(Format.JSON));

      while (p.iterator().hasNext()) {
        Artifact a = p.iterator().next();
        validateArtifact(a);
        count++;
        //				System.out.println(a.getId()+" "+a.getManufacturer().getName() +"  "+count);
      }
      assertEquals("Page total results", 0, p.getTotalSize());
      pageNo = pageNo + p.getPageSize();
      //				System.out.println(results.get().toString());
    } while (!p.isLastPage() && pageNo < p.getTotalSize());
    assertFalse("String handle is not empty", results.get().isEmpty());
    assertTrue("String handle contains results", results.get().contains("results"));
    assertFalse("String handle contains format", results.get().contains("\"format\":\"json\""));

    ObjectMapper mapper = new ObjectMapper();
    JsonNode actNode = mapper.readTree(results.get()).get("total");
    //		System.out.println(expNode.equals(actNode)+"\n"+
    // expNode.toString()+"\n"+actNode.toString());

    assertEquals("Total search results resulted are ", actNode.asInt(), 0);
  }
  @Test
  public void testStructuredSearch() throws IOException {
    QueryManager queryMgr = Common.client.newQueryManager();
    StructuredQueryBuilder qb = queryMgr.newStructuredQueryBuilder();

    for (QueryDefinition t :
        new QueryDefinition[] {qb.term("leaf3"), qb.build(qb.value(qb.element("leaf"), "leaf3"))}) {
      SearchHandle results = queryMgr.search(t, new SearchHandle());
      assertNotNull(results);
      assertFalse(results.getMetrics().getTotalTime() == -1);

      MatchDocumentSummary[] summaries = results.getMatchResults();
      assertNotNull(summaries);
      assertEquals("expected 1 result", 1, summaries.length);
      for (MatchDocumentSummary summary : summaries) {
        MatchLocation[] locations = summary.getMatchLocations();
        assertEquals("expected 1 match location", 1, locations.length);
        for (MatchLocation location : locations) {
          assertNotNull(location.getAllSnippetText());
        }
      }
    }
  }
  @Test
  public void testWithVariousGrammarAndWordQuery()
      throws IOException, ParserConfigurationException, SAXException, XpathException {
    System.out.println("Running testWithVariousGrammarAndWordQuery");

    String[] filenames = {
      "constraint1.xml", "constraint2.xml", "constraint3.xml", "constraint4.xml", "constraint5.xml"
    };
    String queryOptionName = "absRangeConstraintWithVariousGrammarAndWordQueryOpt.xml";

    DatabaseClient client =
        DatabaseClientFactory.newClient(
            "localhost", 8011, "rest-admin", "x", Authentication.DIGEST);

    // write docs
    for (String filename : filenames) {
      writeDocumentUsingInputStreamHandle(client, filename, "/abs-range-constraint/", "XML");
    }

    setQueryOption(client, queryOptionName);

    QueryManager queryMgr = client.newQueryManager();

    // create query def
    StringQueryDefinition querydef = queryMgr.newStringDefinition(queryOptionName);
    querydef.setCriteria("(pop:high OR pop:medium) AND price:medium AND intitle:served");

    // create handle
    DOMHandle resultsHandle = new DOMHandle();
    queryMgr.search(querydef, resultsHandle);

    // get the result
    Document resultDoc = resultsHandle.get();

    assertXpathEvaluatesTo(
        "1", "string(//*[local-name()='result'][last()]//@*[local-name()='index'])", resultDoc);
    assertXpathEvaluatesTo(
        "Vannevar served",
        "string(//*[local-name()='result'][1]//*[local-name()='title'])",
        resultDoc);
    assertXpathEvaluatesTo(
        "12.34", "string(//*[local-name()='result'][1]//@*[local-name()='amt'])", resultDoc);
    assertXpathEvaluatesTo(
        "5", "string(//*[local-name()='result'][1]//*[local-name()='popularity'])", resultDoc);
    assertXpathEvaluatesTo(
        "1", "string(//*[local-name()='facet-value']//@*[local-name()='count'])", resultDoc);
    assertXpathEvaluatesTo("High", "string(//*[local-name()='facet-value'])", resultDoc);

    // String expectedSearchReport = "(cts:search(fn:collection(),
    // cts:and-query((cts:or-query((cts:element-range-query(fn:QName(\"\", \"popularity\"),
    // \"&gt;=\", xs:int(\"5\"), (), 1), cts:and-query((cts:element-range-query(fn:QName(\"\",
    // \"popularity\"), \"&gt;=\", xs:int(\"3\"), (), 1), cts:element-range-query(fn:QName(\"\",
    // \"popularity\"), \"&lt;\", xs:int(\"5\"), (), 1)), ()))),
    // cts:element-attribute-range-query(fn:QName(\"http://cloudbank.com\", \"price\"),
    // fn:QName(\"\", \"amt\"), \"&gt;=\", 3.0, (), 1),
    // cts:element-attribute-range-query(fn:QName(\"http://cloudbank.com\", \"price\"),
    // fn:QName(\"\", \"amt\"), \"&lt;\", 14.0, (), 1), cts:element-word-query(fn:QName(\"\",
    // \"title\"), \"served\", (\"lang=en\"), 1)), ()), (\"score-logtfidf\"), 1))[1 to 10]";

    // assertXpathEvaluatesTo(expectedSearchReport, "string(//*[local-name()='report'])",
    // resultDoc);

    // release client
    client.release();
  }
  // This test is to verify RAW JSON structured query
  @Test
  public void testBulkSearchRawJSONStrucQD() throws Exception {
    //		setAutomaticDirectoryCreation(dbName,"automatic");
    setMaintainLastModified(dbName, true);
    this.loadJSONDocuments();
    this.loadXMLDocuments();
    GenericDocumentManager docMgr = client.newDocumentManager();
    QueryManager queryMgr = client.newQueryManager();
    JacksonHandle jh = new JacksonHandle();
    ObjectMapper mapper = new ObjectMapper();
    //	constructing JSON representation of Raw JSON Structured Query

    ObjectNode txtNode = mapper.createObjectNode();
    txtNode.putArray("text").add("woof");
    ObjectNode termQNode = mapper.createObjectNode();
    termQNode.set("term-query", txtNode);
    ObjectNode queriesArrayNode = mapper.createObjectNode();
    queriesArrayNode.putArray("queries").add(termQNode);

    ObjectNode txtNode2 = mapper.createObjectNode();
    txtNode2.putArray("text").add("bar");
    ObjectNode termQNode2 = mapper.createObjectNode();
    termQNode2.set("term-query", txtNode2);
    queriesArrayNode.withArray("queries").add(termQNode2);

    ObjectNode orQueryNode = mapper.createObjectNode();
    orQueryNode.set("or-query", queriesArrayNode);

    ObjectNode queryArrayNode = mapper.createObjectNode();
    queryArrayNode.putArray("queries").add(orQueryNode);
    ObjectNode mainNode = mapper.createObjectNode();
    mainNode.set("query", queryArrayNode);
    jh.set(mainNode);
    RawStructuredQueryDefinition qd = queryMgr.newRawStructuredQueryDefinition(jh);
    System.out.println(jh.get().toString());
    docMgr.setNonDocumentFormat(Format.JSON);
    JacksonHandle results = new JacksonHandle();
    DocumentPage page = docMgr.search(qd, 1, results);
    DocumentMetadataHandle mh = new DocumentMetadataHandle();

    int count = 1;
    while (count < 4) {
      page = docMgr.search(qd, count, results);

      while (page.hasNext()) {
        DocumentRecord rec = page.next();
        if (rec.getMimetype().contains("xml")) {
          validateRecord(rec, Format.XML);
        } else {
          validateRecord(rec, Format.JSON);
        }
        docMgr.readMetadata(rec.getUri(), mh);
        assertTrue("Records has permissions? ", mh.getPermissions().containsKey("flexrep-eval"));
        assertFalse("Record has collections ?", mh.getCollections().isEmpty());
      }

      count++;
    }
    System.out.println(results.get().toString());
    assertEquals(
        "Total search results before transaction rollback are ",
        "204",
        results.get().get("total").asText());
  }
  /* Searching for boolean and string in XML element using value query.
   * Purpose: To validate QueryBuilder's new value methods (in 8.0) in XML document using an element.
   *
   * Load a file that has a boolean value in a XML attribute and use query def to search on that boolean value
   *
   * Methods used : value(StructuredQueryBuilder.TextIndex index, boolean)
   *                value(StructuredQueryBuilder.TextIndex index, String)
   */
  @Test
  public void testQueryBuilderValueWithBooleanAndString()
      throws XpathException, SAXException, IOException {

    String docId[] = {"play-persons.xml"};

    TextDocumentManager docMgr = client.newTextDocumentManager();
    QueryManager queryMgr = client.newQueryManager();
    DocumentWriteSet writeset = docMgr.newWriteSet();

    // Put meta-data

    DocumentMetadataHandle metadataHandle = new DocumentMetadataHandle();
    metadataHandle.getCollections().addAll("my-collection1", "my-collection2");
    metadataHandle.getPermissions().add("app-user", Capability.UPDATE, Capability.READ);
    metadataHandle.getProperties().put("reviewed", true);
    metadataHandle.getProperties().put("myString", "foo");
    metadataHandle.getProperties().put("myInteger", 10);
    metadataHandle.getProperties().put("myDecimal", 34.56678);
    metadataHandle.getProperties().put("myCalendar", Calendar.getInstance().get(Calendar.YEAR));
    metadataHandle.setQuality(23);

    writeset.addDefault(metadataHandle);

    // Create a new document using StringHandle
    StringBuffer strBuf = new StringBuffer();

    strBuf.append("<PLAY>");
    strBuf.append("<TITLE>All's Well That Ends Well</TITLE>");
    strBuf.append("<PERSONAE>");
    strBuf.append("<TITLE>Dramatis Personae</TITLE>");

    strBuf.append("<PGROUP>");
    strBuf.append("<subgroup>true</subgroup>");

    strBuf.append("<PERSONA>KING OF FRANCE</PERSONA>");
    strBuf.append("<PERSONA>DUKE OF FLORENCE</PERSONA>");
    strBuf.append("<PERSONA>BERTRAM, Count of Rousillon.</PERSONA>");
    strBuf.append("<PERSONA>LAFEU, an old lord.</PERSONA>");
    strBuf.append("</PGROUP>");

    strBuf.append("<PGROUP>");
    strBuf.append("<subgroup>false</subgroup>");

    strBuf.append("<PERSONA>PAROLLES, a follower of Bertram.</PERSONA>");
    strBuf.append("<PERSONA>A Page. </PERSONA>");
    strBuf.append("</PGROUP>");

    strBuf.append("<PGROUP>");
    strBuf.append("<subgroup>false</subgroup>");
    strBuf.append("<PERSONA>COUNTESS OF ROUSILLON, mother to Bertram. </PERSONA>");
    strBuf.append("<PERSONA>HELENA, a gentlewoman protected by the Countess.</PERSONA>");
    strBuf.append("<PERSONA>An old Widow of Florence. </PERSONA>");
    strBuf.append("<PERSONA>DIANA, daughter to the Widow.</PERSONA>");
    strBuf.append("</PGROUP>");

    strBuf.append("<PGROUP>");
    strBuf.append("<subgroup>false</subgroup>");
    strBuf.append("<PERSONA>VIOLENTA</PERSONA>");
    strBuf.append("<PERSONA>MARIANA</PERSONA>");
    strBuf.append("<GRPDESCR>neighbours and friends to the Widow.</GRPDESCR>");
    strBuf.append("</PGROUP>");

    strBuf.append("<PERSONA>Lords, Officers, Soldiers, &amp;c., French and Florentine.</PERSONA>");
    strBuf.append("</PERSONAE>");
    strBuf.append("</PLAY>");

    writeset.add("/1/" + docId[0], new StringHandle().with(strBuf.toString()));
    docMgr.write(writeset);

    docMgr.write(writeset);

    // Search for the range with attribute value true in rangeRelativeBucketConstraintOpt.xml
    // document.
    StructuredQueryBuilder qb = new StructuredQueryBuilder();

    // Build an object that represents StructuredQueryBuilder.ElementAttribute for use in values
    // method
    // that is of type StructuredQueryBuilder.TextIndex

    QueryDefinition qd = qb.value(qb.element("subgroup"), false);

    // Create handle for the result
    StringHandle resultsHandle = new StringHandle().withFormat(Format.XML);
    queryMgr.search(qd, resultsHandle);

    // Get the result
    String resultDoc = resultsHandle.get();

    System.out.println(resultDoc);
    // Verify that search response has found 1 element attribute
    assertXpathEvaluatesTo(
        "fn:doc(\"/1/play-persons.xml\")",
        "string(//*[local-name()='response']//*[local-name()='result']//@*[local-name()='path'])",
        resultDoc);
    assertXpathEvaluatesTo(
        "3", "count(//*[local-name()='response']//*[local-name()='match'])", resultDoc);

    // Search for the following royal (XML ELEMENT) in all-well.xml document.
    StructuredQueryBuilder qbStr = new StructuredQueryBuilder();
    QueryDefinition qdStr =
        qbStr.value(
            qbStr.element("PERSONA"),
            "KING OF FRANCE",
            "DUKE OF FLORENCE",
            "BERTRAM, Count of Rousillon.",
            "LAFEU, an old lord.");

    // Create handle for the result
    StringHandle resultsHandleStr = new StringHandle().withFormat(Format.XML);
    queryMgr.search(qdStr, resultsHandleStr);

    // Get the result
    String resultDocStr = resultsHandleStr.get();

    System.out.println(resultDocStr);
    // Verify that search response has found 4 PERSONA elements under /PLAY/PERSONAE
    assertXpathEvaluatesTo(
        "fn:doc(\"/1/play-persons.xml\")",
        "string(//*[local-name()='response']//*[local-name()='result']//@*[local-name()='path'])",
        resultDocStr);
    assertXpathEvaluatesTo(
        "4", "count(//*[local-name()='response']//*[local-name()='match'])", resultDocStr);
  }