@Test
 public void canProvideJsonOutputFormat() throws Exception {
   OutputFormat format =
       repository.outputFormat(asList(MediaType.APPLICATION_JSON_TYPE), null, null);
   assertNotNull(format);
   assertEquals("\"test\"", format.assemble(ValueRepresentation.string("test")));
 }
 @GET
 @Path(PATH_EXTENSION)
 public Response getExtensionList(@PathParam("name") String name) {
   try {
     return output.ok(this.extensionList(name));
   } catch (PluginLookupException e) {
     return output.notFound(e);
   }
 }
 @GET
 @Path(PATH_GRAPHDB_EXTENSION_METHOD)
 public Response getGraphDatabaseExtensionDescription(
     @PathParam("name") String name, @PathParam("method") String method) {
   try {
     return output.ok(this.describeGraphDatabaseExtension(name, method));
   } catch (PluginLookupException e) {
     return output.notFound(e);
   }
 }
 @Test
 public void cannotProvideStreamingForOtherMediaTypes() throws Exception {
   final Response.ResponseBuilder responseBuilder = mock(Response.ResponseBuilder.class);
   // no streaming
   when(responseBuilder.entity(anyString())).thenReturn(responseBuilder);
   Mockito.verify(responseBuilder, never()).entity(isA(StreamingOutput.class));
   when(responseBuilder.type(Matchers.<MediaType>any())).thenReturn(responseBuilder);
   when(responseBuilder.build()).thenReturn(null);
   OutputFormat format =
       repository.outputFormat(
           asList(MediaType.TEXT_HTML_TYPE), new URI("http://some.host"), streamingHeader());
   assertNotNull(format);
   format.response(responseBuilder, new ExceptionRepresentation(new RuntimeException()));
 }
 @GET
 @Path(PATH_RELATIONSHIP_EXTENSION_METHOD)
 public Response getRelationshipExtensionDescription(
     @PathParam("name") String name,
     @PathParam("method") String method,
     @PathParam("relationshipId") long relationshipId) {
   try {
     return output.ok(this.describeRelationshipExtension(name, method));
   } catch (PluginLookupException e) {
     return output.notFound(e);
   } catch (Exception e) {
     return output.serverError(e.getCause());
   }
 }
  @GET
  public Response getServiceDefinition() {
    ConsoleServiceRepresentation result =
        new ConsoleServiceRepresentation(SERVICE_PATH, sessionFactory.supportedEngines());

    return output.ok(result);
  }
 @Test
 public void canProvideStreamingJsonOutputFormat() throws Exception {
   Response response = mock(Response.class);
   final AtomicReference<StreamingOutput> ref = new AtomicReference<>();
   final Response.ResponseBuilder responseBuilder = mockResponsBuilder(response, ref);
   OutputFormat format =
       repository.outputFormat(asList(MediaType.APPLICATION_JSON_TYPE), null, streamingHeader());
   assertNotNull(format);
   Response returnedResponse =
       format.response(responseBuilder, new MapRepresentation(map("a", "test")));
   assertSame(response, returnedResponse);
   StreamingOutput streamingOutput = ref.get();
   ByteArrayOutputStream baos = new ByteArrayOutputStream();
   streamingOutput.write(baos);
   assertEquals("{\"a\":\"test\"}", baos.toString());
 }
Exemple #8
0
 @Test
 @Graph(value = {"I know you"})
 public void runSimpleQuery() throws Exception {
   Node i = data.get().get("I");
   Representation result = testQuery("start n=node(" + i.getId() + ") return n");
   assertTrue(json.assemble(result).contains("I"));
 }
 @POST
 @Path(PATH_RELATIONSHIP_EXTENSION_METHOD)
 public Response invokeRelationshipExtension(
     @PathParam("name") String name,
     @PathParam("method") String method,
     @PathParam("relationshipId") long relationshipId,
     String data) {
   try {
     return output.ok(
         this.invokeRelationshipExtension(
             relationshipId, name, method, input.readParameterList(data)));
   } catch (RelationshipNotFoundException e) {
     return output.notFound(e);
   } catch (BadInputException e) {
     return output.badRequest(e);
   } catch (PluginLookupException e) {
     return output.notFound(e);
   } catch (BadPluginInvocationException e) {
     return output.badRequest(e.getCause());
   } catch (PluginInvocationFailureException e) {
     return output.serverError(e.getCause());
   } catch (Exception e) {
     return output.serverError(e.getCause());
   }
 }
 @Test
 public void canFormatEmptyObject() throws Exception {
   json.assemble(
       new MappingRepresentation("empty") {
         @Override
         protected void serialize(MappingSerializer serializer) {}
       });
   assertEquals(JsonHelper.createJsonFrom(Collections.emptyMap()), stream.toString());
 }
 @Test
 public void canFormatNode() throws Exception {
   GraphDatabaseService db = new TestGraphDatabaseFactory().newImpermanentDatabase();
   try {
     final Node refNode = db.getReferenceNode();
     json.assemble(new NodeRepresentation(refNode));
   } finally {
     db.shutdown();
   }
   assertTrue(stream.toString().contains("\"self\" : \"http://localhost/node/0\","));
 }
  @POST
  public Response exec(@Context InputFormat input, String data) {
    Map<String, Object> args;
    try {
      args = input.readMap(data);
    } catch (BadInputException e) {
      return output.badRequest(e);
    }

    if (!args.containsKey("command")) {
      return Response.status(Status.BAD_REQUEST)
          .entity("Expected command argument not present.")
          .build();
    }

    ScriptSession scriptSession;
    try {
      scriptSession = getSession(args);
    } catch (IllegalArgumentException e) {
      return output.badRequest(e);
    }

    log.debug(scriptSession.toString());
    try {
      Pair<String, String> result = scriptSession.evaluate((String) args.get("command"));
      List<Representation> list =
          new ArrayList<Representation>(
              asList(
                  ValueRepresentation.string(result.first()),
                  ValueRepresentation.string(result.other())));

      return output.ok(new ListRepresentation(RepresentationType.STRING, list));
    } catch (Exception e) {
      List<Representation> list =
          new ArrayList<Representation>(
              asList(
                  ValueRepresentation.string(e.getClass() + " : " + e.getMessage() + "\n"),
                  ValueRepresentation.string(null)));
      return output.ok(new ListRepresentation(RepresentationType.STRING, list));
    }
  }
  @GET
  @Produces(MediaType.APPLICATION_JSON)
  public Response getDiscoveryDocument() throws URISyntaxException {
    String webAdminManagementUri =
        configuration.getString(
            Configurator.MANAGEMENT_PATH_PROPERTY_KEY, Configurator.DEFAULT_MANAGEMENT_API_PATH);
    String dataUri =
        configuration.getString(
            Configurator.REST_API_PATH_PROPERTY_KEY, Configurator.DEFAULT_DATA_API_PATH);

    DiscoveryRepresentation dr = new DiscoveryRepresentation(webAdminManagementUri, dataUri);
    return outputFormat.ok(dr);
  }
 @Test
 public void canFormatObjectWithStringField() throws Exception {
   json.assemble(
       new MappingRepresentation("string") {
         @Override
         protected void serialize(MappingSerializer serializer) {
           serializer.putString("key", "expected string");
         }
       });
   assertEquals(
       JsonHelper.createJsonFrom(Collections.singletonMap("key", "expected string")),
       stream.toString());
 }
  @Test
  public void canFormatObjectWithUriField() throws Exception {
    json.assemble(
        new MappingRepresentation("uri") {
          @Override
          protected void serialize(MappingSerializer serializer) {
            serializer.putUri("URL", "subpath");
          }
        });

    assertEquals(
        JsonHelper.createJsonFrom(Collections.singletonMap("URL", "http://localhost/subpath")),
        stream.toString());
  }
 @Test
 public void canFormatObjectWithNestedObject() throws Exception {
   json.assemble(
       new MappingRepresentation("nesting") {
         @Override
         protected void serialize(MappingSerializer serializer) {
           serializer.putMapping(
               "nested",
               new MappingRepresentation("data") {
                 @Override
                 protected void serialize(MappingSerializer nested) {
                   nested.putString("data", "expected data");
                 }
               });
         }
       });
   assertEquals(
       JsonHelper.createJsonFrom(
           Collections.singletonMap("nested", Collections.singletonMap("data", "expected data"))),
       stream.toString());
 }
Exemple #17
0
 @Test
 @Graph(
     value = {"I know you", "I know him"},
     nodes = {
       @NODE(
           name = "you",
           properties = {
             @PROP(key = "bool", value = "true", type = GraphDescription.PropType.BOOLEAN),
             @PROP(key = "name", value = "you"),
             @PROP(key = "int", value = "1", type = GraphDescription.PropType.INTEGER)
           })
     })
 public void checkColumns() throws Exception {
   Node i = data.get().get("I");
   Representation result =
       testQuery(
           "start x =node(" + i.getId() + ") match (x) -- (n) return n, n.name?, n.bool?, n.int?");
   String formatted = json.assemble(result);
   System.out.println(formatted);
   assertTrue(formatted.contains("columns"));
   assertTrue(formatted.contains("name"));
 }
 @POST
 @Path(PATH_GRAPHDB_EXTENSION_METHOD)
 public Response invokeGraphDatabaseExtension(
     @PathParam("name") String name, @PathParam("method") String method, String data) {
   try {
     return output.ok(
         this.invokeGraphDatabaseExtension(name, method, input.readParameterList(data)));
   } catch (BadInputException e) {
     return output.badRequest(e);
   } catch (PluginLookupException e) {
     return output.notFound(e);
   } catch (BadPluginInvocationException e) {
     return output.badRequest(e.getCause());
   } catch (SyntaxException e) {
     return output.badRequest(e.getCause());
   } catch (PluginInvocationFailureException e) {
     return output.serverError(e.getCause());
   } catch (Exception e) {
     return output.serverError(e);
   }
 }
 @GET
 public Response getExtensionsList() {
   return output.ok(this.extensionsList());
 }
 @Test
 public void canFormatString() throws Exception {
   json.assemble(ValueRepresentation.string("expected value"));
   assertEquals(stream.toString(), "\"expected value\"");
 }
 @Test
 public void canFormatListOfStrings() throws Exception {
   json.assemble(ListRepresentation.strings("hello", "world"));
   String expectedString = JsonHelper.createJsonFrom(Arrays.asList("hello", "world"));
   assertEquals(expectedString, stream.toString());
 }
 @Test
 public void canFormatInteger() throws Exception {
   json.assemble(ValueRepresentation.number(10));
   assertEquals("10", stream.toString());
 }