Ejemplo n.º 1
0
  /**
   * Find node by exact match.
   *
   * <p>NOTE: Spaces in the URI have to be encoded as +%20+.
   */
  @Documented
  @Test
  public void shouldAddToIndexAndRetrieveItByExactMatch() throws Exception {
    String indexName = "favorites";
    String key = "key";
    String value = "the value";
    long nodeId = createNode();
    value = URIHelper.encode(value);
    // implicitly create the index
    JaxRsResponse response =
        RestRequest.req()
            .post(
                functionalTestHelper.indexNodeUri(indexName),
                createJsonStringFor(nodeId, key, value));
    assertEquals(201, response.getStatus());

    // search it exact
    String entity =
        gen()
            .noGraph()
            .expectedStatus(200)
            .get(functionalTestHelper.indexNodeUri(indexName, key, URIHelper.encode(value)))
            .entity();
    Collection<?> hits = (Collection<?>) JsonHelper.jsonToSingleValue(entity);
    assertEquals(1, hits.size());
  }
Ejemplo n.º 2
0
  @Test
  public void shouldBeAbleToIndexValuesContainingSpaces() throws Exception {
    final long nodeId = helper.createNode();
    final String key = "key";
    final String value = "value with   spaces  in it";

    String indexName = "spacey-values";
    helper.createNodeIndex(indexName);
    final RestRequest request = RestRequest.req();
    JaxRsResponse response =
        request.post(
            functionalTestHelper.indexNodeUri(indexName), createJsonStringFor(nodeId, key, value));

    assertEquals(Status.CREATED.getStatusCode(), response.getStatus());
    URI location = response.getLocation();
    response.close();
    response =
        request.get(functionalTestHelper.indexNodeUri(indexName, key, URIHelper.encode(value)));
    assertEquals(Status.OK.getStatusCode(), response.getStatus());
    Collection<?> hits = (Collection<?>) JsonHelper.jsonToSingleValue(response.getEntity());
    assertEquals(1, hits.size());
    response.close();

    CLIENT.resource(location).delete();
    response =
        request.get(functionalTestHelper.indexNodeUri(indexName, key, URIHelper.encode(value)));
    hits = (Collection<?>) JsonHelper.jsonToSingleValue(response.getEntity());
    assertEquals(0, hits.size());
  }
Ejemplo n.º 3
0
  @Test
  public void shouldGet200AndArrayOfNodeRepsWhenGettingFromIndex() throws PropertyValueException {
    String key = "myKey";
    String value = "myValue";

    String name1 = "Thomas Anderson";
    String name2 = "Agent Smith";

    String indexName = "matrix";
    final RestRequest request = RestRequest.req();
    JaxRsResponse responseToPost =
        request.post(functionalTestHelper.nodeUri(), "{\"name\":\"" + name1 + "\"}");
    assertEquals(201, responseToPost.getStatus());
    String location1 = responseToPost.getHeaders().getFirst(HttpHeaders.LOCATION);
    responseToPost.close();
    responseToPost = request.post(functionalTestHelper.nodeUri(), "{\"name\":\"" + name2 + "\"}");
    assertEquals(201, responseToPost.getStatus());
    String location2 = responseToPost.getHeaders().getFirst(HttpHeaders.LOCATION);
    responseToPost.close();
    responseToPost =
        request.post(
            functionalTestHelper.indexNodeUri(indexName),
            createJsonStringFor(functionalTestHelper.getNodeIdFromUri(location1), key, value));
    assertEquals(201, responseToPost.getStatus());
    String indexLocation1 = responseToPost.getHeaders().getFirst(HttpHeaders.LOCATION);
    responseToPost.close();
    responseToPost =
        request.post(
            functionalTestHelper.indexNodeUri(indexName),
            createJsonStringFor(functionalTestHelper.getNodeIdFromUri(location2), key, value));
    assertEquals(201, responseToPost.getStatus());
    String indexLocation2 = responseToPost.getHeaders().getFirst(HttpHeaders.LOCATION);
    Map<String, String> uriToName = new HashMap<>();
    uriToName.put(indexLocation1, name1);
    uriToName.put(indexLocation2, name2);
    responseToPost.close();

    JaxRsResponse response =
        RestRequest.req().get(functionalTestHelper.indexNodeUri(indexName, key, value));
    assertEquals(200, response.getStatus());
    Collection<?> items = (Collection<?>) JsonHelper.jsonToSingleValue(response.getEntity());
    int counter = 0;
    for (Object item : items) {
      Map<?, ?> map = (Map<?, ?>) item;
      Map<?, ?> properties = (Map<?, ?>) map.get("data");
      assertNotNull(map.get("self"));
      String indexedUri = (String) map.get("indexed");
      assertEquals(uriToName.get(indexedUri), properties.get("name"));
      counter++;
    }
    assertEquals(2, counter);
    response.close();
  }
Ejemplo n.º 4
0
  /** Remove all entries with a given node from an index. */
  @Documented
  @Test
  public void shouldBeAbleToRemoveIndexingById() {
    String key1 = "kvkey1";
    String key2 = "kvkey2";
    String value1 = "value1";
    String value2 = "value2";
    String indexName = "kvnode";
    long node =
        helper.createNode(MapUtil.map(key1, value1, key1, value2, key2, value1, key2, value2));
    helper.addNodeToIndex(indexName, key1, value1, node);
    helper.addNodeToIndex(indexName, key1, value2, node);
    helper.addNodeToIndex(indexName, key2, value1, node);
    helper.addNodeToIndex(indexName, key2, value2, node);

    gen()
        .noGraph()
        .expectedStatus(204)
        .delete(functionalTestHelper.indexNodeUri(indexName) + "/" + node);

    assertEquals(0, helper.getIndexedNodes(indexName, key1, value1).size());
    assertEquals(0, helper.getIndexedNodes(indexName, key1, value2).size());
    assertEquals(0, helper.getIndexedNodes(indexName, key2, value1).size());
    assertEquals(0, helper.getIndexedNodes(indexName, key2, value2).size());
  }
Ejemplo n.º 5
0
  @Test
  public void shouldGetNodeRepresentationFromIndexUri() throws JsonParseException {
    long nodeId = helper.createNode();
    String key = "key2";
    String value = "value";

    String indexName = "mindex";
    helper.createNodeIndex(indexName);
    JaxRsResponse response =
        RestRequest.req()
            .post(
                functionalTestHelper.indexNodeUri(indexName),
                createJsonStringFor(nodeId, key, value));

    assertEquals(Status.CREATED.getStatusCode(), response.getStatus());
    String indexUri = response.getHeaders().getFirst("Location");

    response = RestRequest.req().get(indexUri);
    assertEquals(200, response.getStatus());

    String entity = response.getEntity();

    Map<String, Object> map = JsonHelper.jsonToMap(entity);
    assertNotNull(map.get("self"));
  }
Ejemplo n.º 6
0
  /** Delete node index. */
  @Documented
  @Test
  public void shouldReturn204WhenRemovingNodeIndexes() {
    String indexName = "kvnode";
    helper.createNodeIndex(indexName);

    gen().noGraph().expectedStatus(204).delete(functionalTestHelper.indexNodeUri(indexName));
  }
Ejemplo n.º 7
0
  @Test
  public void orderedResultsAreSupersetOfUnordered() throws Exception {
    // Given
    String indexName = "bobTheIndex";
    String key = "Name";
    String value = "Builder";
    long node = helper.createNode(MapUtil.map(key, value));
    helper.addNodeToIndex(indexName, key, value, node);
    helper.addNodeToIndex(indexName, "Gender", "Male", node);

    String entity =
        gen()
            .expectedStatus(200)
            .get(
                functionalTestHelper.indexNodeUri(indexName)
                    + "?query=Name:Build~0.1%20AND%20Gender:Male")
            .entity();

    Collection<?> hits = (Collection<?>) JsonHelper.jsonToSingleValue(entity);
    LinkedHashMap<String, String> nodeMapUnordered = (LinkedHashMap) hits.iterator().next();

    // When
    entity =
        gen()
            .expectedStatus(200)
            .get(
                functionalTestHelper.indexNodeUri(indexName)
                    + "?query=Name:Build~0.1%20AND%20Gender:Male&order=score")
            .entity();

    hits = (Collection<?>) JsonHelper.jsonToSingleValue(entity);
    LinkedHashMap<String, String> nodeMapOrdered = (LinkedHashMap) hits.iterator().next();

    // Then
    for (Map.Entry<String, String> unorderedEntry : nodeMapUnordered.entrySet()) {
      assertEquals(
          "wrong entry for key: " + unorderedEntry.getKey(),
          unorderedEntry.getValue(),
          nodeMapOrdered.get(unorderedEntry.getKey()));
    }
    assertTrue(
        "There should be only one extra value for the ordered map",
        nodeMapOrdered.size() == nodeMapUnordered.size() + 1);
  }
Ejemplo n.º 8
0
 @Test
 public void shouldRespondWith400WhenSendingCorruptJson() throws Exception {
   final String indexName = "botherable-index";
   helper.createNodeIndex(indexName);
   final String corruptJson = "{\"key\" \"myKey\"}";
   JaxRsResponse response =
       RestRequest.req().post(functionalTestHelper.indexNodeUri(indexName), corruptJson);
   assertEquals(400, response.getStatus());
   response.close();
 }
Ejemplo n.º 9
0
 @Test
 public void shouldGet200WhenGettingNodesFromIndexWithNoHits() {
   String indexName = "empty-index";
   helper.createNodeIndex(indexName);
   JaxRsResponse response =
       RestRequest.req()
           .get(
               functionalTestHelper.indexNodeUri(
                   indexName, "non-existent-key", "non-existent-value"));
   assertEquals(200, response.getStatus());
   response.close();
 }
Ejemplo n.º 10
0
 @Test
 public void shouldGetTrinityWhenSearchingForHer() {
   JaxRsResponse response =
       RestRequest.req()
           .get(
               functionalTestHelper.indexNodeUri("node", "name", "Trinity"),
               MediaType.TEXT_HTML_TYPE);
   assertEquals(Status.OK.getStatusCode(), response.getStatus());
   String entity = response.getEntity();
   assertTrue(entity.contains("Trinity"));
   assertValidHtml(entity);
   response.close();
 }
Ejemplo n.º 11
0
 /**
  * Add node to index.
  *
  * <p>Associates a node with the given key/value pair in the given index.
  *
  * <p>NOTE: Spaces in the URI have to be encoded as +%20+.
  *
  * <p>CAUTION: This does *not* overwrite previous entries. If you index the same key/value/item
  * combination twice, two index entries are created. To do update-type operations, you need to
  * delete the old entry before adding a new one.
  */
 @Documented
 @Test
 public void shouldAddToIndex() throws Exception {
   final String indexName = "favorites";
   final String key = "some-key";
   final String value = "some value";
   long nodeId = createNode();
   // implicitly create the index
   gen()
       .noGraph()
       .expectedStatus(201)
       .payload(
           JsonHelper.createJsonFrom(
               generateNodeIndexCreationPayload(key, value, functionalTestHelper.nodeUri(nodeId))))
       .post(functionalTestHelper.indexNodeUri(indexName));
   // look if we get one entry back
   JaxRsResponse response =
       RestRequest.req()
           .get(functionalTestHelper.indexNodeUri(indexName, key, URIHelper.encode(value)));
   String entity = response.getEntity();
   Collection<?> hits = (Collection<?>) JsonHelper.jsonToSingleValue(entity);
   assertEquals(1, hits.size());
 }
Ejemplo n.º 12
0
  /**
   * POST ${org.neo4j.server.rest.web}/index/node/{indexName}/{key}/{value}
   * "http://uri.for.node.to.index"
   */
  @Test
  public void shouldRespondWith201CreatedWhenIndexingJsonNodeUri() {
    final long nodeId = helper.createNode();
    final String key = "key";
    final String value = "value";
    final String indexName = "testy";
    helper.createNodeIndex(indexName);

    JaxRsResponse response =
        RestRequest.req()
            .post(
                functionalTestHelper.indexNodeUri(indexName),
                createJsonStringFor(nodeId, key, value));
    assertEquals(201, response.getStatus());
    assertNotNull(response.getHeaders().getFirst("Location"));
    assertEquals(Arrays.asList((Long) nodeId), helper.getIndexedNodes(indexName, key, value));
  }
Ejemplo n.º 13
0
  /**
   * Find node by query.
   *
   * <p>The query language used here depends on what type of index you are querying. The default
   * index type is Lucene, in which case you should use the Lucene query language here. Below an
   * example of a fuzzy search over multiple keys.
   *
   * <p>See: {lucene-base-uri}/queryparsersyntax.html
   *
   * <p>Getting the results with a predefined ordering requires adding the parameter
   *
   * <p>`order=ordering`
   *
   * <p>where ordering is one of index, relevance or score. In this case an additional field will be
   * added to each result, named score, that holds the float value that is the score reported by the
   * query result.
   */
  @Documented
  @Test
  public void shouldAddToIndexAndRetrieveItByQuery() throws PropertyValueException {
    String indexName = "bobTheIndex";
    String key = "Name";
    String value = "Builder";
    long node = helper.createNode(MapUtil.map(key, value));
    helper.addNodeToIndex(indexName, key, value, node);
    helper.addNodeToIndex(indexName, "Gender", "Male", node);

    String entity =
        gen()
            .noGraph()
            .expectedStatus(200)
            .get(
                functionalTestHelper.indexNodeUri(indexName)
                    + "?query=Name:Build~0.1%20AND%20Gender:Male")
            .entity();

    Collection<?> hits = (Collection<?>) JsonHelper.jsonToSingleValue(entity);
    assertEquals(1, hits.size());
    LinkedHashMap<String, String> nodeMap = (LinkedHashMap) hits.iterator().next();
    assertNull("score should not be present when not explicitly ordering", nodeMap.get("score"));
  }
Ejemplo n.º 14
0
  @Test
  public void shouldAddToIndexAndRetrieveItByQuerySorted() throws PropertyValueException {
    String indexName = "bobTheIndex";
    String key = "Name";
    long node1 = helper.createNode();
    long node2 = helper.createNode();
    helper.addNodeToIndex(indexName, key, "Builder2", node1);
    helper.addNodeToIndex(indexName, "Gender", "Male", node1);
    helper.addNodeToIndex(indexName, key, "Builder", node2);
    helper.addNodeToIndex(indexName, "Gender", "Male", node2);

    String entity =
        gen()
            .expectedStatus(200)
            .get(
                functionalTestHelper.indexNodeUri(indexName)
                    + "?query=Name:Build~0.1%20AND%20Gender:Male&order=relevance")
            .entity();

    Collection<?> hits = (Collection<?>) JsonHelper.jsonToSingleValue(entity);
    assertEquals(2, hits.size());
    Iterator<LinkedHashMap<String, Object>> it =
        (Iterator<LinkedHashMap<String, Object>>) hits.iterator();

    LinkedHashMap<String, Object> node2Map = it.next();
    LinkedHashMap<String, Object> node1Map = it.next();
    float score2 = ((Double) node2Map.get("score")).floatValue();
    float score1 = ((Double) node1Map.get("score")).floatValue();
    assertTrue(
        "results returned in wrong order for relevance ordering",
        ((String) node2Map.get("self")).endsWith(Long.toString(node2)));
    assertTrue(
        "results returned in wrong order for relevance ordering",
        ((String) node1Map.get("self")).endsWith(Long.toString(node1)));
    /*
     * scores are always the same, just the ordering changes. So all subsequent tests will
     * check the same condition.
     */
    assertTrue("scores are reversed", score2 > score1);

    entity =
        gen()
            .expectedStatus(200)
            .get(
                functionalTestHelper.indexNodeUri(indexName)
                    + "?query=Name:Build~0.1%20AND%20Gender:Male&order=index")
            .entity();

    hits = (Collection<?>) JsonHelper.jsonToSingleValue(entity);
    assertEquals(2, hits.size());
    it = (Iterator<LinkedHashMap<String, Object>>) hits.iterator();

    /*
     * index order, so as they were added
     */
    node1Map = it.next();
    node2Map = it.next();
    score1 = ((Double) node1Map.get("score")).floatValue();
    score2 = ((Double) node2Map.get("score")).floatValue();
    assertTrue(
        "results returned in wrong order for index ordering",
        ((String) node1Map.get("self")).endsWith(Long.toString(node1)));
    assertTrue(
        "results returned in wrong order for index ordering",
        ((String) node2Map.get("self")).endsWith(Long.toString(node2)));
    assertTrue("scores are reversed", score2 > score1);

    entity =
        gen()
            .expectedStatus(200)
            .get(
                functionalTestHelper.indexNodeUri(indexName)
                    + "?query=Name:Build~0.1%20AND%20Gender:Male&order=score")
            .entity();

    hits = (Collection<?>) JsonHelper.jsonToSingleValue(entity);
    assertEquals(2, hits.size());
    it = (Iterator<LinkedHashMap<String, Object>>) hits.iterator();

    node2Map = it.next();
    node1Map = it.next();
    score2 = ((Double) node2Map.get("score")).floatValue();
    score1 = ((Double) node1Map.get("score")).floatValue();
    assertTrue(
        "results returned in wrong order for score ordering",
        ((String) node2Map.get("self")).endsWith(Long.toString(node2)));
    assertTrue(
        "results returned in wrong order for score ordering",
        ((String) node1Map.get("self")).endsWith(Long.toString(node1)));
    assertTrue("scores are reversed", score2 > score1);
  }