/******************************************************************************
* Copyright (c) 2016 TypeFox and others.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v. 2.0 which is available at
* http://www.eclipse.org/legal/epl-2.0,
* or the Eclipse Distribution License v. 1.0 which is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
******************************************************************************/
package org.eclipse.lsp4j.jsonrpc.test.json;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Consumer;
import org.eclipse.lsp4j.jsonrpc.json.JsonRpcMethod;
import org.eclipse.lsp4j.jsonrpc.json.MessageJsonHandler;
import org.eclipse.lsp4j.jsonrpc.messages.Either;
import org.eclipse.lsp4j.jsonrpc.messages.Message;
import org.eclipse.lsp4j.jsonrpc.messages.NotificationMessage;
import org.eclipse.lsp4j.jsonrpc.messages.RequestMessage;
import org.eclipse.lsp4j.jsonrpc.messages.ResponseError;
import org.eclipse.lsp4j.jsonrpc.messages.ResponseMessage;
import org.junit.Assert;
import org.junit.Test;
import com.google.gson.JsonArray;
import com.google.gson.JsonObject;
import com.google.gson.reflect.TypeToken;
public class MessageJsonHandlerTest {
public static class Entry {
public String name;
public int kind;
public Location location;
}
public static class Location {
public String uri;
}
@SuppressWarnings({ "unchecked" })
@Test
public void testParseList_01() {
Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>();
supportedMethods.put("foo", JsonRpcMethod.request("foo",
new TypeToken<List<? extends Entry>>() {}.getType(),
new TypeToken<List<? extends Entry>>() {}.getType()));
MessageJsonHandler handler = new MessageJsonHandler(supportedMethods);
handler.setMethodProvider((id)->"foo");
Message message = handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ " \"result\": [\n"
+ " {\"name\":\"$schema\",\"kind\":15,\"location\":{\"uri\":\"file:/home/mistria/runtime-EclipseApplication-with-patch/EclipseConEurope/something.json\",\"range\":{\"start\":{\"line\":1,\"character\":3},\"end\":{\"line\":1,\"character\":55}}}},\n"
+ " {\"name\":\"type\",\"kind\":15,\"location\":{\"uri\":\"file:/home/mistria/runtime-EclipseApplication-with-patch/EclipseConEurope/something.json\",\"range\":{\"start\":{\"line\":2,\"character\":3},\"end\":{\"line\":2,\"character\":19}}}},\n"
+ " {\"name\":\"title\",\"kind\":15,\"location\":{\"uri\":\"file:/home/mistria/runtime-EclipseApplication-with-patch/EclipseConEurope/something.json\",\"range\":{\"start\":{\"line\":3,\"character\":3},\"end\":{\"line\":3,\"character\":50}}}},\n"
+ " {\"name\":\"additionalProperties\",\"kind\":17,\"location\":{\"uri\":\"file:/home/mistria/runtime-EclipseApplication-with-patch/EclipseConEurope/something.json\",\"range\":{\"start\":{\"line\":4,\"character\":4},\"end\":{\"line\":4,\"character\":32}}}},\n"
+ " {\"name\":\"properties\",\"kind\":15,\"location\":{\"uri\":\"file:/home/mistria/runtime-EclipseApplication-with-patch/EclipseConEurope/something.json\",\"range\":{\"start\":{\"line\":5,\"character\":3},\"end\":{\"line\":5,\"character\":20}}}}\n"
+ "]}");
List<? extends Entry> result = (List<? extends Entry>) ((ResponseMessage) message).getResult();
Assert.assertEquals(5, result.size());
for (Entry e : result) {
Assert.assertTrue(e.location.uri, e.location.uri.startsWith("file:/home/mistria"));
}
}
@SuppressWarnings({ "unchecked" })
@Test
public void testParseList_02() {
Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>();
supportedMethods.put("foo", JsonRpcMethod.request("foo",
new TypeToken<Set<Entry>>() {}.getType(),
new TypeToken<Set<Entry>>() {}.getType()));
MessageJsonHandler handler = new MessageJsonHandler(supportedMethods);
handler.setMethodProvider((id)->"foo");
Message message = handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ " \"result\": [\n"
+ " {\"name\":\"$schema\",\"kind\":15,\"location\":{\"uri\":\"file:/home/mistria/runtime-EclipseApplication-with-patch/EclipseConEurope/something.json\",\"range\":{\"start\":{\"line\":1,\"character\":3},\"end\":{\"line\":1,\"character\":55}}}},\n"
+ " {\"name\":\"type\",\"kind\":15,\"location\":{\"uri\":\"file:/home/mistria/runtime-EclipseApplication-with-patch/EclipseConEurope/something.json\",\"range\":{\"start\":{\"line\":2,\"character\":3},\"end\":{\"line\":2,\"character\":19}}}},\n"
+ " {\"name\":\"title\",\"kind\":15,\"location\":{\"uri\":\"file:/home/mistria/runtime-EclipseApplication-with-patch/EclipseConEurope/something.json\",\"range\":{\"start\":{\"line\":3,\"character\":3},\"end\":{\"line\":3,\"character\":50}}}},\n"
+ " {\"name\":\"additionalProperties\",\"kind\":17,\"location\":{\"uri\":\"file:/home/mistria/runtime-EclipseApplication-with-patch/EclipseConEurope/something.json\",\"range\":{\"start\":{\"line\":4,\"character\":4},\"end\":{\"line\":4,\"character\":32}}}},\n"
+ " {\"name\":\"properties\",\"kind\":15,\"location\":{\"uri\":\"file:/home/mistria/runtime-EclipseApplication-with-patch/EclipseConEurope/something.json\",\"range\":{\"start\":{\"line\":5,\"character\":3},\"end\":{\"line\":5,\"character\":20}}}}\n"
+ "]}");
Set<Entry> result = (Set<Entry>) ((ResponseMessage)message).getResult();
Assert.assertEquals(5, result.size());
for (Entry e : result) {
Assert.assertTrue(e.location.uri, e.location.uri.startsWith("file:/home/mistria"));
}
}
@Test
public void testParseNullList() {
Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>();
supportedMethods.put("foo", JsonRpcMethod.request("foo",
new TypeToken<List<? extends Entry>>() {}.getType(),
new TypeToken<List<? extends Entry>>() {}.getType()));
MessageJsonHandler handler = new MessageJsonHandler(supportedMethods);
handler.setMethodProvider((id)->"foo");
Message message = handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ " \"result\": null}");
Assert.assertNull(((ResponseMessage)message).getResult());
}
@SuppressWarnings({ "unchecked" })
@Test
public void testParseEmptyList() {
Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>();
supportedMethods.put("foo", JsonRpcMethod.request("foo",
new TypeToken<List<? extends Entry>>() {}.getType(),
new TypeToken<List<? extends Entry>>() {}.getType()));
MessageJsonHandler handler = new MessageJsonHandler(supportedMethods);
handler.setMethodProvider((id)->"foo");
Message message = handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ " \"result\": []}");
List<Entry> result = (List<Entry>) ((ResponseMessage)message).getResult();
Assert.assertEquals(0, result.size());
}
@Test
public void testSerializeEmptyList() {
MessageJsonHandler handler = new MessageJsonHandler(Collections.emptyMap());
NotificationMessage message = new NotificationMessage();
message.setMethod("foo");
message.setParams(Collections.EMPTY_LIST);
String json = handler.serialize(message);
Assert.assertEquals("{\"jsonrpc\":\"2.0\",\"method\":\"foo\",\"params\":[]}", json);
}
@Test
public void testSerializeImmutableList() {
MessageJsonHandler handler = new MessageJsonHandler(Collections.emptyMap());
NotificationMessage message = new NotificationMessage();
message.setMethod("foo");
List<Object> list = new ArrayList<>();
list.add("a");
list.add("b");
message.setParams(Collections.unmodifiableList(list));
String json = handler.serialize(message);
Assert.assertEquals("{\"jsonrpc\":\"2.0\",\"method\":\"foo\",\"params\":[\"a\",\"b\"]}", json);
}
@SuppressWarnings({ "unchecked" })
@Test
public void testEither_01() {
Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>();
supportedMethods.put("foo", JsonRpcMethod.request("foo",
new TypeToken<Either<String, List<Map<String,String>>>>() {}.getType(),
new TypeToken<Either<String, Integer>>() {}.getType()));
MessageJsonHandler handler = new MessageJsonHandler(supportedMethods);
handler.setMethodProvider((id) -> "foo");
Message message = handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ " \"result\": [\n"
+ " {\"name\":\"foo\"},\n"
+ " {\"name\":\"bar\"}\n"
+ "]}");
Either<String, List<Map<String, String>>> result = (Either<String, List<Map<String,String>>>) ((ResponseMessage)message).getResult();
Assert.assertTrue(result.isRight());
for (Map<String, String> e : result.getRight()) {
Assert.assertNotNull(e.get("name"));
}
message = handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ "\"result\": \"name\"\n"
+ "}");
result = (Either<String, List<Map<String,String>>>) ((ResponseMessage)message).getResult();
Assert.assertFalse(result.isRight());
Assert.assertEquals("name", result.getLeft());
}
@SuppressWarnings({ "unchecked" })
@Test
public void testEither_02() {
Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>();
supportedMethods.put("foo", JsonRpcMethod.request("foo",
new TypeToken<Either<MyEnum, Map<String,String>>>() {}.getType(),
new TypeToken<Object>() {}.getType()));
MessageJsonHandler handler = new MessageJsonHandler(supportedMethods);
handler.setMethodProvider((id) -> "foo");
Message message = handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ "\"result\": 2\n"
+ "}");
Either<MyEnum, List<Map<String, String>>> result = (Either<MyEnum, List<Map<String,String>>>) ((ResponseMessage)message).getResult();
Assert.assertTrue(result.isLeft());
Assert.assertEquals(MyEnum.B, result.getLeft());
}
@SuppressWarnings({ "unchecked" })
@Test
public void testEither_03() {
Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>();
supportedMethods.put("foo", JsonRpcMethod.request("foo",
new TypeToken<Either<Either<MyEnum, Map<String,String>>, List<Either<MyEnum, Map<String,String>>>>>() {}.getType(),
new TypeToken<Object>() {}.getType()));
MessageJsonHandler handler = new MessageJsonHandler(supportedMethods);
handler.setMethodProvider((id) -> "foo");
Message message = handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ "\"result\": 2\n"
+ "}");
Either<Either<MyEnum, Map<String,String>>, List<Either<MyEnum, Map<String,String>>>> result = (Either<Either<MyEnum, Map<String, String>>, List<Either<MyEnum, Map<String, String>>>>) ((ResponseMessage)message).getResult();
Assert.assertTrue(result.isLeft());
Assert.assertTrue(result.getLeft().isLeft());
Assert.assertEquals(MyEnum.B, result.getLeft().getLeft());
message = handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ " \"result\": {\n"
+ " \"foo\":\"1\",\n"
+ " \"bar\":\"2\"\n"
+ "}}");
result = (Either<Either<MyEnum, Map<String, String>>, List<Either<MyEnum, Map<String, String>>>>) ((ResponseMessage)message).getResult();
Assert.assertTrue(result.isLeft());
Assert.assertTrue(result.getLeft().isRight());
Assert.assertEquals("1", result.getLeft().getRight().get("foo"));
Assert.assertEquals("2", result.getLeft().getRight().get("bar"));
message = handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ " \"result\": [{\n"
+ " \"foo\":\"1\",\n"
+ " \"bar\":\"2\"\n"
+ "}]}");
result = (Either<Either<MyEnum, Map<String, String>>, List<Either<MyEnum, Map<String, String>>>>) ((ResponseMessage)message).getResult();
Assert.assertTrue(result.isRight());
Assert.assertTrue(result.getRight().get(0).isRight());
Assert.assertEquals("1", result.getRight().get(0).getRight().get("foo"));
Assert.assertEquals("2", result.getRight().get(0).getRight().get("bar"));
message = handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ " \"result\": [\n"
+ " 2\n"
+ "]}");
result = (Either<Either<MyEnum, Map<String, String>>, List<Either<MyEnum, Map<String, String>>>>) ((ResponseMessage)message).getResult();
Assert.assertTrue(result.isRight());
Assert.assertTrue(result.getRight().get(0).isLeft());
Assert.assertEquals(MyEnum.B, result.getRight().get(0).getLeft());
}
@SuppressWarnings({ "unchecked" })
@Test
public void testEither_04() {
Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>();
supportedMethods.put("foo", JsonRpcMethod.request("foo",
new TypeToken<Either<MyClass, List<? extends MyClass>>>() {}.getType(),
new TypeToken<Object>() {}.getType()));
MessageJsonHandler handler = new MessageJsonHandler(supportedMethods);
handler.setMethodProvider((id) -> "foo");
Message message = handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ "\"result\": {\n"
+ " value:\"foo\"\n"
+ "}}");
Either<MyClass, List<? extends MyClass>> result = (Either<MyClass, List<? extends MyClass>>) ((ResponseMessage)message).getResult();
Assert.assertTrue(result.isLeft());
Assert.assertEquals("foo", result.getLeft().getValue());
message = handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ "\"result\": [{\n"
+ " value:\"bar\"\n"
+ "}]}");
result = (Either<MyClass, List<? extends MyClass>>) ((ResponseMessage)message).getResult();
Assert.assertTrue(result.isRight());
Assert.assertEquals("bar", result.getRight().get(0).getValue());
}
@SuppressWarnings({ "unchecked" })
@Test
public void testEither_05() {
Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>();
supportedMethods.put("foo", JsonRpcMethod.request("foo",
new TypeToken<Either<List<MyClass>, MyClassList>>() {}.getType(),
new TypeToken<Object>() {}.getType()));
MessageJsonHandler handler = new MessageJsonHandler(supportedMethods);
handler.setMethodProvider((id) -> "foo");
Message message = handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ "\"result\": [{\n"
+ " value:\"foo\"\n"
+ "}]}");
Either<List<MyClass>, MyClassList> result = (Either<List<MyClass>, MyClassList>) ((ResponseMessage)message).getResult();
Assert.assertTrue(result.isLeft());
Assert.assertEquals("foo", result.getLeft().get(0).getValue());
message = handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ "\"result\": {\n"
+ " items: [{\n"
+ " value:\"bar\"\n"
+ "}]}}");
result = (Either<List<MyClass>, MyClassList>) ((ResponseMessage)message).getResult();
Assert.assertTrue(result.isRight());
Assert.assertEquals("bar", result.getRight().getItems().get(0).getValue());
}
@Test
public void testParamsParsing_01() {
Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>();
supportedMethods.put("foo", JsonRpcMethod.request("foo",
new TypeToken<Void>() {}.getType(),
new TypeToken<Location>() {}.getType()));
MessageJsonHandler handler = new MessageJsonHandler(supportedMethods);
handler.setMethodProvider((id) -> "foo");
RequestMessage message = (RequestMessage) handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ "\"params\": {\"uri\": \"dummy://mymodel.mydsl\"},\n"
+ "\"method\":\"foo\"\n"
+ "}");
Assert.assertEquals(Location.class, message.getParams().getClass());
}
@Test
public void testParamsParsing_02() {
Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>();
supportedMethods.put("foo", JsonRpcMethod.request("foo",
new TypeToken<Void>() {}.getType(),
new TypeToken<Location>() {}.getType()));
MessageJsonHandler handler = new MessageJsonHandler(supportedMethods);
handler.setMethodProvider((id) -> "foo");
RequestMessage message = (RequestMessage) handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ "\"method\":\"foo\",\n"
+ "\"params\": {\"uri\": \"dummy://mymodel.mydsl\"}\n"
+ "}");
Assert.assertEquals(Location.class, message.getParams().getClass());
}
@Test
public void testParamsParsing_03() {
Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>();
supportedMethods.put("foo", JsonRpcMethod.request("foo",
new TypeToken<Void>() {}.getType(),
new TypeToken<Location>() {}.getType()));
MessageJsonHandler handler = new MessageJsonHandler(supportedMethods);
handler.setMethodProvider((id) -> "foo");
RequestMessage message = (RequestMessage) handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ "\"method\":\"bar\",\n"
+ "\"params\": {\"uri\": \"dummy://mymodel.mydsl\"}\n"
+ "}");
Assert.assertEquals(JsonObject.class, message.getParams().getClass());
}
@Test
public void testParamsParsing_04() {
Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>();
supportedMethods.put("foo", JsonRpcMethod.request("foo",
new TypeToken<Void>() {}.getType(),
new TypeToken<Location>() {}.getType()));
MessageJsonHandler handler = new MessageJsonHandler(supportedMethods);
handler.setMethodProvider((id) -> "foo");
RequestMessage message = (RequestMessage) handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ "\"method\":\"bar\",\n"
+ "\"params\": null\n"
+ "}");
Assert.assertEquals(null, message.getParams());
}
@Test
public void testRawMultiParamsParsing_01() {
Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>();
supportedMethods.put("foo", JsonRpcMethod.request("foo",
new TypeToken<Void>() {}.getType(),
new TypeToken<String>() {}.getType(),
new TypeToken<Integer>() {}.getType()));
MessageJsonHandler handler = new MessageJsonHandler(supportedMethods);
handler.setMethodProvider((id) -> "foo");
RequestMessage message = (RequestMessage) handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ "\"method\":\"foo\",\n"
+ "\"params\": [\"foo\", 2]\n"
+ "}");
Assert.assertTrue("" + message.getParams().getClass(), message.getParams() instanceof List);
List<?> parameters = (List<?>) message.getParams();
Assert.assertEquals(2, parameters.size());
Assert.assertEquals("foo", parameters.get(0));
Assert.assertEquals(2, parameters.get(1));
}
@Test
public void testRawMultiParamsParsing_02() {
Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>();
supportedMethods.put("foo", JsonRpcMethod.request("foo",
new TypeToken<Void>() {}.getType(),
new TypeToken<String>() {}.getType(),
new TypeToken<Integer>() {}.getType()));
MessageJsonHandler handler = new MessageJsonHandler(supportedMethods);
handler.setMethodProvider((id) -> "foo");
RequestMessage message = (RequestMessage) handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ "\"method\":\"bar\",\n"
+ "\"params\": [\"foo\", 2]\n"
+ "}");
Assert.assertTrue("" + message.getParams().getClass(), message.getParams() instanceof JsonArray);
}
@Test
public void testRawMultiParamsParsing_03() {
Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>();
supportedMethods.put("foo", JsonRpcMethod.request("foo",
new TypeToken<Void>() {}.getType(),
new TypeToken<List<String>>() {}.getType(),
new TypeToken<List<Integer>>() {}.getType(),
new TypeToken<Location>() {}.getType()));
MessageJsonHandler handler = new MessageJsonHandler(supportedMethods);
handler.setMethodProvider((id) -> "foo");
RequestMessage message = (RequestMessage) handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ "\"method\":\"foo\",\n"
+ "\"params\": [[\"foo\", \"bar\"], [1, 2], {\"uri\": \"dummy://mymodel.mydsl\"}]\n"
+ "}");
Assert.assertTrue("" + message.getParams().getClass(), message.getParams() instanceof List);
List<?> parameters = (List<?>) message.getParams();
Assert.assertEquals(3, parameters.size());
Assert.assertEquals("[foo, bar]", parameters.get(0).toString());
Assert.assertEquals("[1, 2]", parameters.get(1).toString());
Assert.assertTrue("" + parameters.get(2).getClass(), parameters.get(2) instanceof Location);
}
@Test
public void testRawMultiParamsParsing_04() {
Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>();
supportedMethods.put("foo", JsonRpcMethod.request("foo",
new TypeToken<Void>() {}.getType(),
new TypeToken<List<String>>() {}.getType(),
new TypeToken<List<Integer>>() {}.getType(),
new TypeToken<Location>() {}.getType()));
MessageJsonHandler handler = new MessageJsonHandler(supportedMethods);
handler.setMethodProvider((id) -> "foo");
RequestMessage message = (RequestMessage) handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ "\"method\":\"foo\",\n"
+ "\"params\": [[\"foo\", \"bar\"], [1, 2]]\n"
+ "}");
Assert.assertTrue("" + message.getParams().getClass(), message.getParams() instanceof List);
List<?> parameters = (List<?>) message.getParams();
Assert.assertEquals(3, parameters.size());
Assert.assertEquals("[foo, bar]", parameters.get(0).toString());
Assert.assertEquals("[1, 2]", parameters.get(1).toString());
Assert.assertNull(parameters.get(2));
}
@Test
public void testMultiParamsParsing_01() {
Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>();
supportedMethods.put("foo", JsonRpcMethod.request("foo",
new TypeToken<Void>() {}.getType(),
new TypeToken<String>() {}.getType(),
new TypeToken<Integer>() {}.getType()));
MessageJsonHandler handler = new MessageJsonHandler(supportedMethods);
handler.setMethodProvider((id) -> "foo");
RequestMessage message = (RequestMessage) handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ "\"params\": [\"foo\", 2],\n"
+ "\"method\":\"foo\"\n"
+ "}");
Assert.assertTrue("" + message.getParams().getClass(), message.getParams() instanceof List);
List<?> parameters = (List<?>) message.getParams();
Assert.assertEquals(2, parameters.size());
Assert.assertEquals("foo", parameters.get(0));
Assert.assertEquals(2, parameters.get(1));
}
@Test
public void testMultiParamsParsing_02() {
Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>();
supportedMethods.put("foo", JsonRpcMethod.request("foo",
new TypeToken<Void>() {}.getType(),
new TypeToken<String>() {}.getType(),
new TypeToken<Integer>() {}.getType()));
MessageJsonHandler handler = new MessageJsonHandler(supportedMethods);
handler.setMethodProvider((id) -> "foo");
RequestMessage message = (RequestMessage) handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ "\"params\": [\"foo\", 2],\n"
+ "\"method\":\"bar\"\n"
+ "}");
Assert.assertTrue("" + message.getParams().getClass(), message.getParams() instanceof JsonArray);
}
@Test
public void testMultiParamsParsing_03() {
Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>();
supportedMethods.put("foo", JsonRpcMethod.request("foo",
new TypeToken<Void>() {}.getType(),
new TypeToken<List<String>>() {}.getType(),
new TypeToken<List<Integer>>() {}.getType(),
new TypeToken<Location>() {}.getType()));
MessageJsonHandler handler = new MessageJsonHandler(supportedMethods);
handler.setMethodProvider((id) -> "foo");
RequestMessage message = (RequestMessage) handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ "\"params\": [[\"foo\", \"bar\"], [1, 2], {\"uri\": \"dummy://mymodel.mydsl\"}],\n"
+ "\"method\":\"foo\"\n"
+ "}");
Assert.assertTrue("" + message.getParams().getClass(), message.getParams() instanceof List);
List<?> parameters = (List<?>) message.getParams();
Assert.assertEquals(3, parameters.size());
Assert.assertEquals("[foo, bar]", parameters.get(0).toString());
Assert.assertEquals("[1, 2]", parameters.get(1).toString());
Assert.assertTrue("" + parameters.get(2).getClass(), parameters.get(2) instanceof Location);
}
@Test
public void testMultiParamsParsing_04() {
Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>();
supportedMethods.put("foo", JsonRpcMethod.request("foo",
new TypeToken<Void>() {}.getType(),
new TypeToken<List<String>>() {}.getType(),
new TypeToken<List<Integer>>() {}.getType(),
new TypeToken<Location>() {}.getType()));
MessageJsonHandler handler = new MessageJsonHandler(supportedMethods);
handler.setMethodProvider((id) -> "foo");
RequestMessage message = (RequestMessage) handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ "\"params\": [[\"foo\", \"bar\"], [1, 2]],\n"
+ "\"method\":\"foo\"\n"
+ "}");
Assert.assertTrue("" + message.getParams().getClass(), message.getParams() instanceof List);
List<?> parameters = (List<?>) message.getParams();
Assert.assertEquals(3, parameters.size());
Assert.assertEquals("[foo, bar]", parameters.get(0).toString());
Assert.assertEquals("[1, 2]", parameters.get(1).toString());
Assert.assertNull(parameters.get(2));
}
@Test
public void testEnumParam() {
Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>();
supportedMethods.put("foo", JsonRpcMethod.request("foo",
new TypeToken<Void>() {}.getType(),
new TypeToken<List<MyEnum>>() {}.getType()));
MessageJsonHandler handler = new MessageJsonHandler(supportedMethods);
handler.setMethodProvider((id) -> "foo");
RequestMessage message = (RequestMessage) handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ "\"params\": [1, 2, 3],\n"
+ "\"method\":\"foo\"\n"
+ "}");
Assert.assertTrue("" + message.getParams().getClass(), message.getParams() instanceof List);
List<?> parameters = (List<?>) message.getParams();
Assert.assertEquals(Arrays.asList(MyEnum.A, MyEnum.B, MyEnum.C),
parameters);
}
@Test
public void testEnumParamNull() {
Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>();
supportedMethods.put("foo", JsonRpcMethod.request("foo",
new TypeToken<Void>() {}.getType(),
new TypeToken<List<MyEnum>>() {}.getType()));
MessageJsonHandler handler = new MessageJsonHandler(supportedMethods);
handler.setMethodProvider((id) -> "foo");
RequestMessage message = (RequestMessage) handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ "\"params\": [1, 2, null],\n"
+ "\"method\":\"foo\"\n"
+ "}");
Assert.assertTrue("" + message.getParams().getClass(), message.getParams() instanceof List);
List<?> parameters = (List<?>) message.getParams();
Assert.assertEquals(Arrays.asList(MyEnum.A, MyEnum.B, null),
parameters);
}
@Test
public void testResponseErrorData() {
MessageJsonHandler handler = new MessageJsonHandler(Collections.emptyMap());
ResponseMessage message = (ResponseMessage) handler.parseMessage("{\"jsonrpc\":\"2.0\","
+ "\"id\":\"2\",\n"
+ "\"error\": { \"code\": -32001, \"message\": \"foo\",\n"
+ " \"data\": { \"uri\": \"file:/foo\", \"version\": 5, \"list\": [\"a\", \"b\", \"c\"] }\n"
+ " }\n"
+ "}");
ResponseError error = message.getError();
Assert.assertTrue("Expected a JsonObject in error.data", error.getData() instanceof JsonObject);
JsonObject data = (JsonObject) error.getData();
Assert.assertEquals("file:/foo", data.get("uri").getAsString());
Assert.assertEquals(5, data.get("version").getAsInt());
JsonArray list = data.get("list").getAsJsonArray();
Assert.assertEquals("a", list.get(0).getAsString());
Assert.assertEquals("b", list.get(1).getAsString());
Assert.assertEquals("c", list.get(2).getAsString());
}
public static final <T> void swap(T[] a, int i, int j) {
T t = a[i];
a[i] = a[j];
a[j] = t;
}
public <T> void testAllPermutationsInner(T[] array, int i, int n, Consumer<T[]> test) {
int j;
if (i == n) {
test.accept(array);
} else {
for (j = i; j <= n; j++) {
swap(array, i, j);
testAllPermutationsInner(array, i + 1, n, test);
swap(array, i, j);
}
}
}
public <T> void testAllPermutationsStart(T[] array, Consumer<T[]> test) {
testAllPermutationsInner(array, 0, array.length - 1, test);
}
public void testAllPermutations(String[] properties, Consumer<String> test) {
testAllPermutationsStart(properties, mutatedProperties -> {
StringBuilder json = new StringBuilder();
json.append("{");
for (int k = 0; k < mutatedProperties.length; k++) {
json.append(mutatedProperties[k]);
if (k != mutatedProperties.length - 1) {
json.append(",");
}
}
json.append("}");
String jsonString = json.toString();
try {
test.accept(jsonString);
} catch (Exception | AssertionError e) {
// To make it easier to debug a failing test, add another exception
// layer that shows the version of the json used -- you may
// need to turn off "Filter Stack Trace" in JUnit view in Eclipse
// to see the underlying error.
throw new AssertionError("Failed with this input json: " + jsonString, e);
}
});
}
@Test
public void testThePermutationsTest() {
// make sure that the testAllPermutations works as expected
Set<String> collectedPermutations = new HashSet<>();
Set<String> expectedPermutations = new HashSet<>();
expectedPermutations.add("{a,b,c}");
expectedPermutations.add("{a,c,b}");
expectedPermutations.add("{b,a,c}");
expectedPermutations.add("{b,c,a}");
expectedPermutations.add("{c,a,b}");
expectedPermutations.add("{c,b,a}");
testAllPermutations(new String[] {"a", "b", "c"}, perm -> collectedPermutations.add(perm));
Assert.assertEquals(expectedPermutations, collectedPermutations);
}
@Test
public void testRequest_AllOrders() {
Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>();
supportedMethods.put("foo", JsonRpcMethod.request("foo",
new TypeToken<Void>() {}.getType(),
new TypeToken<Location>() {
}.getType()));
MessageJsonHandler handler = new MessageJsonHandler(supportedMethods);
handler.setMethodProvider((id) -> "foo");
String[] properties = new String[] {
"\"jsonrpc\":\"2.0\"",
"\"id\":2",
"\"method\":\"foo\"",
"\"params\": {\"uri\": \"dummy://mymodel.mydsl\"}"
};
testAllPermutations(properties, json -> {
RequestMessage message = (RequestMessage) handler.parseMessage(json);
Object params = message.getParams();
Class<? extends Object> class1 = params.getClass();
Assert.assertEquals(Location.class, class1);
Assert.assertEquals("dummy://mymodel.mydsl", ((Location)params).uri);
});
}
@Test
public void testNormalResponse_AllOrders() {
Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>();
supportedMethods.put("foo", JsonRpcMethod.request("foo",
new TypeToken<Location>() {}.getType(),
new TypeToken<Void>() {
}.getType()));
MessageJsonHandler handler = new MessageJsonHandler(supportedMethods);
handler.setMethodProvider((id) -> "foo");
String[] properties = new String[] {
"\"jsonrpc\":\"2.0\"",
"\"id\":2",
"\"result\": {\"uri\": \"dummy://mymodel.mydsl\"}"
};
testAllPermutations(properties, json -> {
ResponseMessage message = (ResponseMessage) handler.parseMessage(json);
Object result = message.getResult();
Class<? extends Object> class1 = result.getClass();
Assert.assertEquals(Location.class, class1);
Assert.assertEquals("dummy://mymodel.mydsl", ((Location)result).uri);
Assert.assertNull(message.getError());
});
}
@Test
public void testErrorResponse_AllOrders() {
Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>();
supportedMethods.put("foo", JsonRpcMethod.request("foo",
new TypeToken<Location>() {}.getType(),
new TypeToken<Void>() {
}.getType()));
MessageJsonHandler handler = new MessageJsonHandler(supportedMethods);
handler.setMethodProvider((id) -> "foo");
String[] properties = new String[] {
"\"jsonrpc\":\"2.0\"",
"\"id\":2",
"\"message\": \"failed\"",
"\"error\": {\"code\": 123456, \"message\": \"failed\", \"data\": {\"uri\": \"failed\"}}"
};
testAllPermutations(properties, json -> {
ResponseMessage message = (ResponseMessage) handler.parseMessage(json);
Assert.assertEquals("failed", message.getError().getMessage());
Object data = message.getError().getData();
JsonObject expected = new JsonObject();
expected.addProperty("uri", "failed");
Assert.assertEquals(expected, data);
Assert.assertNull(message.getResult());
});
}
@Test
public void testNotification_AllOrders() {
Map<String, JsonRpcMethod> supportedMethods = new LinkedHashMap<>();
supportedMethods.put("foo", JsonRpcMethod.request("foo",
new TypeToken<Void>() {}.getType(),
new TypeToken<Location>() {
}.getType()));
MessageJsonHandler handler = new MessageJsonHandler(supportedMethods);
handler.setMethodProvider((id) -> "foo");
String[] properties = new String[] {
"\"jsonrpc\":\"2.0\"",
"\"method\":\"foo\"",
"\"params\": {\"uri\": \"dummy://mymodel.mydsl\"}"
};
testAllPermutations(properties, json -> {
NotificationMessage message = (NotificationMessage) handler.parseMessage(json);
Object params = message.getParams();
Class<? extends Object> class1 = params.getClass();
Assert.assertEquals(Location.class, class1);
Assert.assertEquals("dummy://mymodel.mydsl", ((Location)params).uri);
});
}
}
