This is an automated email from the ASF dual-hosted git repository.
jin pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/incubator-hugegraph.git
The following commit(s) were added to refs/heads/master by this push:
new ca5fc0cb2 fix(server): support GraphAPI for rocksdb & add tests (#2900)
ca5fc0cb2 is described below
commit ca5fc0cb29281f5b0c1002261736acfd6e1b3f9f
Author: Tsukilc <[email protected]>
AuthorDate: Tue Nov 4 19:33:25 2025 +0800
fix(server): support GraphAPI for rocksdb & add tests (#2900)
---
.../apache/hugegraph/api/profile/GraphsAPI.java | 8 +-
.../apache/hugegraph/api/space/GraphSpaceAPI.java | 3 +-
.../org/apache/hugegraph/core/GraphManager.java | 61 +++-
.../org/apache/hugegraph/StandardHugeGraph.java | 2 +-
.../java/org/apache/hugegraph/api/BaseApiTest.java | 20 ++
.../org/apache/hugegraph/api/GraphsApiTest.java | 325 ++++++++++++++++++++-
6 files changed, 392 insertions(+), 27 deletions(-)
diff --git
a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/profile/GraphsAPI.java
b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/profile/GraphsAPI.java
index aef06dca9..5f10da09e 100644
---
a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/profile/GraphsAPI.java
+++
b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/profile/GraphsAPI.java
@@ -29,6 +29,7 @@ import org.apache.hugegraph.HugeGraph;
import org.apache.hugegraph.api.API;
import org.apache.hugegraph.api.filter.StatusFilter;
import org.apache.hugegraph.auth.HugeAuthenticator.RequiredPerm;
+import org.apache.hugegraph.auth.HugeGraphAuthProxy;
import org.apache.hugegraph.auth.HugePermission;
import org.apache.hugegraph.config.HugeConfig;
import org.apache.hugegraph.core.GraphManager;
@@ -128,7 +129,7 @@ public class GraphsAPI extends API {
LOG.debug("Get graph by name '{}'", name);
HugeGraph g = graph(manager, graphSpace, name);
- return ImmutableMap.of("name", g.spaceGraphName(), "backend",
g.backend());
+ return ImmutableMap.of("name", g.name(), "backend", g.backend());
}
@DELETE
@@ -198,8 +199,7 @@ public class GraphsAPI extends API {
}
}
- // todo: auth get actual user info
- String creator = "admin";
+ String creator = HugeGraphAuthProxy.getContext().user().username();
if (StringUtils.isNotEmpty(clone)) {
// Clone from existing graph
@@ -214,7 +214,7 @@ public class GraphsAPI extends API {
if (description == null) {
description = Strings.EMPTY;
}
- Object result = ImmutableMap.of("name", graph.spaceGraphName(),
+ Object result = ImmutableMap.of("name", graph.name(),
"nickname", graph.nickname(),
"backend", graph.backend(),
"description", description);
diff --git
a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/space/GraphSpaceAPI.java
b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/space/GraphSpaceAPI.java
index c4f604aac..4f12a59cf 100644
---
a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/space/GraphSpaceAPI.java
+++
b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/api/space/GraphSpaceAPI.java
@@ -26,6 +26,7 @@ import org.apache.commons.codec.digest.DigestUtils;
import org.apache.commons.lang.StringUtils;
import org.apache.hugegraph.api.API;
import org.apache.hugegraph.api.filter.StatusFilter.Status;
+import org.apache.hugegraph.auth.HugeGraphAuthProxy;
import org.apache.hugegraph.core.GraphManager;
import org.apache.hugegraph.define.Checkable;
import org.apache.hugegraph.exception.NotFoundException;
@@ -103,7 +104,7 @@ public class GraphSpaceAPI extends API {
jsonGraphSpace.checkCreate(false);
- String creator = "admin";
+ String creator = HugeGraphAuthProxy.getContext().user().username();
GraphSpace exist = manager.graphSpace(jsonGraphSpace.name);
E.checkArgument(exist == null, "The graph space '%s' has existed",
jsonGraphSpace.name);
diff --git
a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/core/GraphManager.java
b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/core/GraphManager.java
index 24949314a..a2659641b 100644
---
a/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/core/GraphManager.java
+++
b/hugegraph-server/hugegraph-api/src/main/java/org/apache/hugegraph/core/GraphManager.java
@@ -22,6 +22,7 @@ import static
org.apache.hugegraph.space.GraphSpace.DEFAULT_GRAPH_SPACE_DESCRIPT
import static
org.apache.hugegraph.space.GraphSpace.DEFAULT_GRAPH_SPACE_SERVICE_NAME;
import java.io.IOException;
+import java.io.StringWriter;
import java.text.ParseException;
import java.util.Arrays;
import java.util.Collections;
@@ -1227,10 +1228,42 @@ public final class GraphManager {
public HugeGraph createGraph(String graphSpace, String name, String
creator,
Map<String, Object> configs, boolean init) {
if (!usePD()) {
- return createGraphLocal(configs.toString(), name);
+ // Extract nickname from configs
+ String nickname;
+ if (configs.get("nickname") != null) {
+ nickname = configs.get("nickname").toString();
+ checkNickname(nickname);
+ } else {
+ nickname = name;
+ }
+
+ Date timeStamp = new Date();
+
+ // Convert Map to Properties format string
+ PropertiesConfiguration propConfig = new PropertiesConfiguration();
+ for (Map.Entry<String, Object> entry : configs.entrySet()) {
+ propConfig.setProperty(entry.getKey(), entry.getValue());
+ }
+ StringWriter writer = new StringWriter();
+ try {
+ propConfig.write(writer);
+ } catch (Exception e) {
+ throw new HugeException("Failed to convert config map to
properties", e);
+ }
+
+ HugeGraph graph = createGraphLocal(name, writer.toString());
+
+ // Set metadata fields for non-PD mode
+ graph.nickname(nickname);
+ graph.creator(creator);
+ graph.createTime(timeStamp);
+ graph.updateTime(timeStamp);
+
+ return graph;
}
- // When the registered graph space is not DEFAULT, only the graphs
within that registered graph space are loaded.
+ // When the registered graph space is not DEFAULT, only the graphs
within that registered
+ // graph space are loaded.
if (!"DEFAULT".equals(this.serviceGraphSpace) &&
!this.serviceGraphSpace.equals(graphSpace)) {
throw new HugeException(String.format(
@@ -1291,7 +1324,7 @@ public final class GraphManager {
Date timeStamp = new Date();
- configs.putIfAbsent("nickname", nickname);
+ // Note: nickname was already extracted and removed from configs
earlier
configs.putIfAbsent("creator", creator);
configs.putIfAbsent("create_time", timeStamp);
configs.putIfAbsent("update_time", timeStamp);
@@ -1514,7 +1547,7 @@ public final class GraphManager {
}
private String defaultSpaceGraphName(String graphName) {
- return "DEFAULT-" + graphName;
+ return spaceGraphName("DEFAULT", graphName);
}
private void loadGraph(String name, String graphConfPath) {
@@ -1931,7 +1964,7 @@ public final class GraphManager {
}
public void dropGraphLocal(String name) {
- HugeGraph graph = this.graph(name);
+ HugeGraph graph = this.graph(DEFAULT_GRAPH_SPACE_SERVICE_NAME + "-" +
name);
E.checkArgument(this.conf.get(ServerOptions.ENABLE_DYNAMIC_CREATE_DROP),
"Not allowed to drop graph '%s' dynamically, " +
"please set `enable_dynamic_create_drop` to true.",
@@ -2052,6 +2085,17 @@ public final class GraphManager {
public Set<String> graphs(String graphSpace) {
Set<String> graphs = new HashSet<>();
+
+ if (!usePD()) {
+ for (String key : this.graphs.keySet()) {
+ String[] parts = key.split(DELIMITER);
+ if (parts[0].equals(graphSpace)) {
+ graphs.add(parts[1]);
+ }
+ }
+ return graphs;
+ }
+
for (String key : this.metaManager.graphConfigs(graphSpace).keySet()) {
graphs.add(key.split(DELIMITER)[1]);
}
@@ -2107,6 +2151,13 @@ public final class GraphManager {
public void graphReadMode(String graphSpace, String graphName,
GraphReadMode readMode) {
+
+ if (!usePD()) {
+ HugeGraph g = this.graph(spaceGraphName(graphSpace, graphName));
+ g.readMode(readMode);
+ return;
+ }
+
try {
Map<String, Object> configs =
this.metaManager.getGraphConfig(graphSpace, graphName);
diff --git
a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/StandardHugeGraph.java
b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/StandardHugeGraph.java
index 9d5f5b720..faf97aa8d 100644
---
a/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/StandardHugeGraph.java
+++
b/hugegraph-server/hugegraph-core/src/main/java/org/apache/hugegraph/StandardHugeGraph.java
@@ -1120,7 +1120,7 @@ public class StandardHugeGraph implements HugeGraph {
this.serverStarted(nodeInfo);
// Write config to the disk file
- String confPath = ConfigUtil.writeToFile(configPath,
this.spaceGraphName(),
+ String confPath = ConfigUtil.writeToFile(configPath, this.name,
this.configuration());
this.configuration.file(confPath);
}
diff --git
a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/BaseApiTest.java
b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/BaseApiTest.java
index 45fceafc7..f88c134ab 100644
---
a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/BaseApiTest.java
+++
b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/BaseApiTest.java
@@ -74,6 +74,15 @@ public class BaseApiTest {
private static final String GRAPH_EDGE = "/graph/edges";
private static final String BATCH = "/batch";
+ private static final String ROCKSDB_CONFIG_TEMPLATE =
+ "{ \"gremlin.graph\": \"org.apache.hugegraph.HugeFactory\"," +
+ "\"backend\": \"rocksdb\", \"serializer\": \"binary\"," +
+ "\"store\": \"%s\", \"nickname\": \"%s\"," +
+ "\"rocksdb.data_path\": \"rocksdbtest-data-%s\"," +
+ "\"rocksdb.wal_path\": \"rocksdbtest-data-%s\"," +
+ "\"search.text_analyzer\": \"jieba\"," +
+ "\"search.text_analyzer_mode\": \"INDEX\" }";
+
protected static RestClient client;
private static final ObjectMapper MAPPER = new ObjectMapper();
@@ -661,6 +670,17 @@ public class BaseApiTest {
return createGraph(graphSpace, name, name);
}
+ public static Response createGraphInRocksDB(String graphSpace, String
name) {
+ return createGraphInRocksDB(graphSpace, name, name);
+ }
+
+ public static Response createGraphInRocksDB(String graphSpace, String name,
+ String nickname) {
+ String path = String.format("graphspaces/%s/graphs/%s", graphSpace,
name);
+ String config = String.format(ROCKSDB_CONFIG_TEMPLATE, name, nickname,
name, name);
+ return client.post(path, Entity.json(config));
+ }
+
public static Response createGraph(String graphSpace, String name,
String nickname) {
String config = "{\n" +
diff --git
a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/GraphsApiTest.java
b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/GraphsApiTest.java
index 469a83e51..efd7c3e76 100644
---
a/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/GraphsApiTest.java
+++
b/hugegraph-server/hugegraph-test/src/main/java/org/apache/hugegraph/api/GraphsApiTest.java
@@ -18,42 +18,335 @@
package org.apache.hugegraph.api;
import java.util.HashMap;
+import java.util.List;
import java.util.Map;
-import org.junit.AfterClass;
-import org.junit.BeforeClass;
+import org.apache.hugegraph.util.JsonUtil;
+import org.junit.Assert;
import org.junit.Test;
+import com.google.common.collect.ImmutableMap;
+
+import jakarta.ws.rs.client.Entity;
import jakarta.ws.rs.core.Response;
public class GraphsApiTest extends BaseApiTest {
- private static final String TEMP_SPACE = "graph_test";
- private static final String TEMP_AUTH_SPACE = "graph_auth_test";
- private static final String PATH = "graphspaces/graph_test/graphs";
- private static final String PATH_AUTH = "graphspaces/graph_auth_test" +
- "/graphs";
+ private static final String TEMP_SPACE = "DEFAULT";
+ private static final String PATH = "graphspaces/DEFAULT/graphs";
+
+ @Test
+ public void testListGraphs() {
+ try {
+ // Create multiple graphs
+ Response r1 = createGraphInRocksDB(TEMP_SPACE, "listtest1");
+ assertResponseStatus(201, r1);
+
+ Response r2 = createGraphInRocksDB(TEMP_SPACE, "listtest2");
+ assertResponseStatus(201, r2);
+
+ // List all graphs
+ Response r = client().get(PATH);
+ String content = assertResponseStatus(200, r);
+
+ Map<String, Object> result = JsonUtil.fromJson(content, Map.class);
+ Assert.assertTrue(result.containsKey("graphs"));
+
+ @SuppressWarnings("unchecked")
+ List<String> graphs = (List<String>) result.get("graphs");
+ Assert.assertTrue(graphs.contains("listtest1"));
+ Assert.assertTrue(graphs.contains("listtest2"));
+ } finally {
+ // Clean up
+ Map<String, Object> params = ImmutableMap.of(
+ "confirm_message", "I'm sure to drop the graph");
+ client().delete(PATH + "/listtest1", params);
+ client().delete(PATH + "/listtest2", params);
+ }
+ }
+
+ @Test
+ public void testGetGraph() {
+ try {
+ // Create a graph
+ Response r = createGraphInRocksDB(TEMP_SPACE, "get_test",
"GetTestGraph");
+ assertResponseStatus(201, r);
+
+ // Get the graph
+ Response getResponse = client().get(PATH + "/get_test");
+ String content = assertResponseStatus(200, getResponse);
+
+ Map<String, Object> result = JsonUtil.fromJson(content, Map.class);
+ Assert.assertTrue(result.containsKey("name"));
+ Assert.assertTrue(result.containsKey("backend"));
+ Assert.assertEquals("get_test", result.get("name"));
+ } finally {
+ // Clean up
+ Map<String, Object> params = ImmutableMap.of(
+ "confirm_message", "I'm sure to drop the graph");
+ client().delete(PATH + "/get_test", params);
+ }
+ }
+
+ @Test
+ public void testcreateGraphInRocksDB() {
+ try {
+ String config = "{\n" +
+ " \"gremlin.graph\":
\"org.apache.hugegraph.HugeFactory\",\n" +
+ " \"backend\": \"rocksdb\",\n" +
+ " \"serializer\": \"binary\",\n" +
+ " \"store\": \"create_test\",\n" +
+ " \"nickname\": \"CreateTestGraph\",\n" +
+ " \"description\": \"Test graph creation\",\n" +
+ " \"rocksdb.data_path\":
\"rocksdbtest-data-create_test\",\n" +
+ " \"rocksdb.wal_path\":
\"rocksdbtest-data-create_test\"\n" +
+ "}";
+
+ Response r = client().post(PATH + "/create_test",
+ Entity.json(config));
+ String content = assertResponseStatus(201, r);
+
+ Map<String, Object> result = JsonUtil.fromJson(content, Map.class);
+ Assert.assertEquals("create_test", result.get("name"));
+ Assert.assertEquals("CreateTestGraph", result.get("nickname"));
+ Assert.assertEquals("rocksdb", result.get("backend"));
+ Assert.assertEquals("Test graph creation",
result.get("description"));
+ } finally {
+ // Clean up
+ Map<String, Object> params = ImmutableMap.of(
+ "confirm_message", "I'm sure to drop the graph");
+ client().delete(PATH + "/create_test", params);
+ }
+ }
+
+ @Test
+ public void testcreateGraphInRocksDBWithMissingRequiredParams() {
+ // Missing 'backend' parameter
+ String config = "{\n" +
+ " \"serializer\": \"binary\",\n" +
+ " \"store\": \"invalid_test\"\n" +
+ "}";
- @BeforeClass
- public static void prepareSpace() {
- createSpace(TEMP_SPACE, false);
- createSpace(TEMP_AUTH_SPACE, true);
+ Response r = client().post(PATH + "/invalid_test",
+ Entity.json(config));
+ Assert.assertTrue(r.getStatus() >= 400);
}
- @AfterClass
- public static void tearDown() {
- clearSpaces();
+ @Test
+ public void testCloneGraph() {
+ try {
+ // Create source graph
+ Response r1 = createGraphInRocksDB(TEMP_SPACE, "clone_source",
"SourceGraph");
+ assertResponseStatus(201, r1);
+
+ // Clone the graph
+ String config = "{\n" +
+ " \"gremlin.graph\":
\"org.apache.hugegraph.HugeFactory\",\n" +
+ " \"backend\": \"rocksdb\",\n" +
+ " \"serializer\": \"binary\",\n" +
+ " \"store\": \"clone_target\",\n" +
+ " \"nickname\": \"ClonedGraph\",\n" +
+ " \"rocksdb.data_path\":
\"rocksdbtest-data-clone_target\",\n" +
+ " \"rocksdb.wal_path\":
\"rocksdbtest-data-clone_target\"\n" +
+ "}";
+
+ Map<String, Object> params = ImmutableMap.of(
+ "clone_graph_name", "clone_source");
+
+ String path = PATH + "/clone_target";
+ Response r = client().target(baseUrl())
+ .path(path)
+ .queryParam("clone_graph_name",
"clone_source")
+ .request()
+ .post(Entity.json(config));
+
+ String content = assertResponseStatus(201, r);
+ Map<String, Object> result = JsonUtil.fromJson(content, Map.class);
+ Assert.assertEquals("clone_target", result.get("name"));
+ } finally {
+ // Clean up
+ Map<String, Object> deleteParams = ImmutableMap.of(
+ "confirm_message", "I'm sure to drop the graph");
+ client().delete(PATH + "/clone_source", deleteParams);
+ client().delete(PATH + "/clone_target", deleteParams);
+ }
}
@Test
public void testDeleteGraph() {
- Response r = createGraph(TEMP_SPACE, "delete");
+ Response r = createGraphInRocksDB(TEMP_SPACE, "delete_test");
assertResponseStatus(201, r);
Map<String, Object> params = new HashMap<>();
params.put("confirm_message", "I'm sure to drop the graph");
- r = client().delete(PATH + "/delete", params);
+ r = client().delete(PATH + "/delete_test", params);
assertResponseStatus(204, r);
+
+ // Verify graph is deleted
+ Response getResponse = client().get(PATH + "/delete_test");
+ Assert.assertTrue(getResponse.getStatus() >= 400);
+ }
+
+ @Test
+ public void testDeleteGraphWithoutConfirmMessage() {
+ try {
+ Response r = createGraphInRocksDB(TEMP_SPACE, "delete_no_confirm");
+ assertResponseStatus(201, r);
+
+ // Try to delete without confirmation
+ Response deleteResponse = client().delete(PATH +
"/delete_no_confirm",
+ new HashMap<>());
+ Assert.assertTrue(deleteResponse.getStatus() >= 400);
+ } finally {
+ // Clean up properly
+ Map<String, Object> params = ImmutableMap.of(
+ "confirm_message", "I'm sure to drop the graph");
+ client().delete(PATH + "/delete_no_confirm", params);
+ }
+ }
+
+ @Test
+ public void testClearGraph() {
+ try {
+ Response r = createGraphInRocksDB(TEMP_SPACE, "clear_test");
+ assertResponseStatus(201, r);
+
+ Map<String, Object> params = ImmutableMap.of(
+ "confirm_message", "I'm sure to delete all data");
+
+ Response clearResponse = client().delete(PATH +
"/clear_test/clear",
+ params);
+ assertResponseStatus(204, clearResponse);
+ } finally {
+ // Clean up
+ Map<String, Object> deleteParams = ImmutableMap.of(
+ "confirm_message", "I'm sure to drop the graph");
+ client().delete(PATH + "/clear_test", deleteParams);
+ }
+ }
+
+ @Test
+ public void testClearGraphWithoutConfirmMessage() {
+ try {
+ Response r = createGraphInRocksDB(TEMP_SPACE, "clear_no_confirm");
+ assertResponseStatus(201, r);
+
+ // Try to clear without confirmation
+ Response clearResponse = client().delete(PATH +
"/clear_no_confirm/clear",
+ new HashMap<>());
+ Assert.assertTrue(clearResponse.getStatus() >= 400);
+ } finally {
+ // Clean up
+ Map<String, Object> params = ImmutableMap.of(
+ "confirm_message", "I'm sure to drop the graph");
+ client().delete(PATH + "/clear_no_confirm", params);
+ }
+ }
+
+ @Test
+ public void testSetGraphMode() {
+ try {
+ Response r = createGraphInRocksDB(TEMP_SPACE, "mode_test");
+ assertResponseStatus(201, r);
+
+ // Set mode to RESTORING
+ String modeJson = "\"RESTORING\"";
+ Response modeResponse = client().target(baseUrl())
+ .path(PATH + "/mode_test/mode")
+ .request()
+ .put(Entity.json(modeJson));
+
+ String content = assertResponseStatus(200, modeResponse);
+ Map<String, Object> result = JsonUtil.fromJson(content, Map.class);
+ Assert.assertEquals("RESTORING", result.get("mode"));
+ } finally {
+ // Clean up
+ Map<String, Object> params = ImmutableMap.of(
+ "confirm_message", "I'm sure to drop the graph");
+ client().delete(PATH + "/mode_test", params);
+ }
+ }
+
+ @Test
+ public void testGetGraphMode() {
+ try {
+ Response r = createGraphInRocksDB(TEMP_SPACE, "get_mode_test");
+ assertResponseStatus(201, r);
+
+ Response modeResponse = client().get(PATH + "/get_mode_test/mode");
+ String content = assertResponseStatus(200, modeResponse);
+
+ Map<String, Object> result = JsonUtil.fromJson(content, Map.class);
+ Assert.assertTrue(result.containsKey("mode"));
+ } finally {
+ // Clean up
+ Map<String, Object> params = ImmutableMap.of(
+ "confirm_message", "I'm sure to drop the graph");
+ client().delete(PATH + "/get_mode_test", params);
+ }
+ }
+
+ @Test
+ public void testSetGraphReadMode() {
+ try {
+ Response r = createGraphInRocksDB(TEMP_SPACE, "read_mode_test");
+ assertResponseStatus(201, r);
+
+ // Set read mode to OLTP_ONLY
+ String readModeJson = "\"OLTP_ONLY\"";
+ Response readModeResponse = client().target(baseUrl())
+ .path(PATH +
"/read_mode_test/graph_read_mode")
+ .request()
+
.put(Entity.json(readModeJson));
+
+ String content = assertResponseStatus(200, readModeResponse);
+ Map<String, Object> result = JsonUtil.fromJson(content, Map.class);
+ Assert.assertEquals("OLTP_ONLY", result.get("graph_read_mode"));
+ } finally {
+ // Clean up
+ Map<String, Object> params = ImmutableMap.of(
+ "confirm_message", "I'm sure to drop the graph");
+ client().delete(PATH + "/read_mode_test", params);
+ }
+ }
+
+ @Test
+ public void testGetGraphReadMode() {
+ try {
+ Response r = createGraphInRocksDB(TEMP_SPACE,
"get_read_mode_test");
+ assertResponseStatus(201, r);
+
+ Response readModeResponse = client().get(PATH +
"/get_read_mode_test/graph_read_mode");
+ String content = assertResponseStatus(200, readModeResponse);
+
+ Map<String, Object> result = JsonUtil.fromJson(content, Map.class);
+ Assert.assertTrue(result.containsKey("graph_read_mode"));
+ } finally {
+ // Clean up
+ Map<String, Object> params = ImmutableMap.of(
+ "confirm_message", "I'm sure to drop the graph");
+ client().delete(PATH + "/get_read_mode_test", params);
+ }
+ }
+
+ @Test
+ public void testReloadGraphsWithInvalidAction() {
+ String actionJson = "{\n" +
+ " \"action\": \"invalid_action\"\n" +
+ "}";
+
+ Response r = client().target(baseUrl())
+ .path(PATH + "/manage")
+ .request()
+ .put(Entity.json(actionJson));
+
+ Assert.assertTrue(r.getStatus() >= 400);
+ }
+
+ @Test
+ public void testGraphNotExist() {
+ Response r = client().get(PATH + "/non_existent_graph");
+ Assert.assertTrue(r.getStatus() >= 400);
}
}
