juick-server: protocol cleanup

5 files changed, 100 insertions, 121 deletions

diff --git a/juick-server/src/main/java/com/juick/server/protocol/JuickProtocol.java b/juick-server/src/main/java/com/juick/server/protocol/JuickProtocol.java
index 6ad177a8..ef8641f8 100644
--- a/juick-server/src/main/java/com/juick/server/protocol/JuickProtocol.java
+++ b/juick-server/src/main/java/com/juick/server/protocol/JuickProtocol.java
@@ -57,7 +57,7 @@ public class JuickProtocol {
      * @throws IllegalAccessException
      * @throws NoSuchMethodException
      */
-    public ProtocolReply getReply(User user, String userInput) throws InvocationTargetException,
+    public String getReply(User user, String userInput) throws InvocationTargetException,
             IllegalAccessException, NoSuchMethodException {
         Optional<Method> cmd = MethodUtils.getMethodsListWithAnnotation(getClass(), UserCommand.class).stream()
                 .filter(m -> Pattern.compile(m.getAnnotation(UserCommand.class).pattern(),
@@ -75,32 +75,32 @@ public class JuickProtocol {
                     groups.add(matcher.group(i));
                 }
             }
-            return (ProtocolReply) getClass().getMethod(cmd.get().getName(), User.class, String[].class)
+            return (String) getClass().getMethod(cmd.get().getName(), User.class, String[].class)
                     .invoke(this, user, groups.toArray(new String[groups.size()]));
         }
     }
 
-    public ProtocolReply postMessage(User user, String input) {
+    public String postMessage(User user, String input) {
         List<Tag> tags = tagService.fromString(input, false);
         String body = input.substring(TagUtils.toString(tags).length());
         int mid = messagesService.createMessage(user.getUid(), body, null, tags);
         subscriptionService.subscribeMessage(mid, user.getUid());
         listener.messagePosted(messagesService.getMessage(mid));
-        return new ProtocolReply("New message posted.\n#" + mid + " " + baseUri + mid);
+        return "New message posted.\n#" + mid + " " + baseUri + mid;
     }
 
     @UserCommand(pattern = "^#\\+$", help = "#+ - Show last Juick messages")
-    public ProtocolReply commandLast(User user, String... arguments) {
+    public String commandLast(User user, String... arguments) {
         List<Integer> mids = messagesService.getAll(user.getUid(), 0);
         List<Message> messages = messagesService.getMessages(mids);
-        return new ProtocolReply("Last messages: \n"
+        return "Last messages: \n"
                 + messages.stream().sorted(Collections.reverseOrder()).map(PlainTextFormatter::formatPostSummary)
-                .collect(Collectors.joining("\n\n")));
+                .collect(Collectors.joining("\n\n"));
     }
 
     @UserCommand(pattern = "^bl$", patternFlags = Pattern.CASE_INSENSITIVE,
             help = "BL - Show your blacklist")
-    public ProtocolReply commandBL(User user_from, String... arguments) {
+    public String commandBL(User user_from, String... arguments) {
         List<User> blusers;
         List<String> bltags;
 
@@ -126,44 +126,44 @@ public class JuickProtocol {
         if (txt.isEmpty()) {
             txt = "You don't have any users or tags in your blacklist.";
         }
-        return new ProtocolReply(txt);
+        return txt;
     }
 
     @UserCommand(pattern = "^bl\\s+@([^\\s\\n\\+]+)", patternFlags = Pattern.CASE_INSENSITIVE,
             help = "BL @username - add @username to your blacklist")
-    public ProtocolReply blacklistUser(User from, String... arguments) {
+    public String blacklistUser(User from, String... arguments) {
         User blUser = userService.getUserByName(arguments[0]);
         if (blUser != null) {
             PrivacyQueriesService.PrivacyResult result = privacyQueriesService.blacklistUser(from, blUser);
             if (result == PrivacyQueriesService.PrivacyResult.Added) {
-                return new ProtocolReply("User added to your blacklist");
+                return "User added to your blacklist";
             } else {
-                return new ProtocolReply("User removed from your blacklist");
+                return "User removed from your blacklist";
             }
         }
-        return new ProtocolReply("User not found");
+        return "User not found";
     }
 
     @UserCommand(pattern = "^bl\\s\\*(\\S+)$", patternFlags = Pattern.CASE_INSENSITIVE,
             help = "BL *tag - add *tag to your blacklist")
-    public ProtocolReply blacklistTag(User from, String... arguments) {
+    public String blacklistTag(User from, String... arguments) {
         User blUser = userService.getUserByName(arguments[0]);
         if (blUser != null) {
             Tag tag = tagService.getTag(arguments[0], false);
             if (tag != null) {
                 PrivacyQueriesService.PrivacyResult result = privacyQueriesService.blacklistTag(from, tag);
                 if (result == PrivacyQueriesService.PrivacyResult.Added) {
-                    return new ProtocolReply("Tag added to your blacklist");
+                    return "Tag added to your blacklist";
                 } else {
-                    return new ProtocolReply("Tag removed from your blacklist");
+                    return "Tag removed from your blacklist";
                 }
             }
         }
-        return new ProtocolReply("Tag not found");
+        return "Tag not found";
     }
 
     @UserCommand(pattern = "@", help = "@ - Show recommendations and popular personal blogs")
-    public ProtocolReply commandUsers(User currentUser, String... args) {
+    public String commandUsers(User currentUser, String... args) {
         StringBuilder msg = new StringBuilder();
         msg.append("Recommended blogs");
         List<String> recommendedUsers = showQueriesService.getRecommendedUsers(currentUser);
@@ -183,20 +183,20 @@ public class JuickProtocol {
         } else {
             msg.append("\nNo top users. Empty DB? ;)");
         }
-        return new ProtocolReply(msg.toString());
+        return msg.toString();
     }
 
     @UserCommand(pattern = "\\*", help = "* - Show your tags")
-    public ProtocolReply commandTags(User currentUser, String... args) {
+    public String commandTags(User currentUser, String... args) {
         List<TagStats> tags = tagService.getUserTagStats(currentUser.getUid());
         String msg = "Your tags: (tag - messages)\n" +
                 tags.stream()
                         .map(t -> String.format("\n*%s - %d", t.getTag().getName(), t.getUsageCount())).collect(Collectors.joining());
-        return new ProtocolReply(msg);
+        return msg;
     }
 
     @UserCommand(pattern = "S", help = "S - Show your subscriptions")
-    public ProtocolReply commandSubscriptions(User currentUser, String... args) {
+    public String commandSubscriptions(User currentUser, String... args) {
         List<User> friends = userService.getUserFriends(currentUser.getUid());
         List<String> tags = subscriptionService.getSubscribedTags(currentUser);
         String msg = friends.size() > 0 ? "You are subscribed to users:" + friends.stream().map(u -> "\n@" + u.getName())
@@ -205,65 +205,65 @@ public class JuickProtocol {
         msg += tags.size() > 0 ? "\nYou are subscribed to tags:" + tags.stream().map(t -> "\n*" + t)
                 .collect(Collectors.joining())
                 : "\nYou are not subscribed to any tag.";
-        return new ProtocolReply(msg);
+        return msg;
     }
 
     @UserCommand(pattern = "!", help = "! - Show your favorite messages")
-    public ProtocolReply commandFavorites(User currentUser, String... args) {
+    public String commandFavorites(User currentUser, String... args) {
         List<Integer> mids = messagesService.getUserRecommendations(currentUser.getUid(), 0);
         if (mids.size() > 0) {
             List<Message> messages = messagesService.getMessages(mids);
-            return new ProtocolReply("Favorite messages: \n" + String.join("\n", messages.stream().map(PlainTextFormatter::formatPost)
-                    .collect(Collectors.toList())));
+            return "Favorite messages: \n" + String.join("\n", messages.stream().map(PlainTextFormatter::formatPost)
+                    .collect(Collectors.toList()));
         }
-        return new ProtocolReply("No favorite messages, try to \"like\" something ;)");
+        return "No favorite messages, try to \"like\" something ;)";
     }
 
     @UserCommand(pattern = "^\\@([^\\s\\n\\+]+)(\\+?)$",
             help = "@username+ - Show user's info and last 10 messages (@username++ - second page, ..)")
-    public ProtocolReply commandUser(User user, String... arguments) {
+    public String commandUser(User user, String... arguments) {
         User blogUser = userService.getUserByName(arguments[0]);
         int page = arguments[1].length();
         if (blogUser.getUid() > 0) {
             List<Integer> mids = messagesService.getUserBlog(blogUser.getUid(), 0, page);
             List<Message> messages = messagesService.getMessages(mids);
-            return new ProtocolReply(String.format("Last messages from @%s:\n%s", arguments[0],
+            return String.format("Last messages from @%s:\n%s", arguments[0],
                     String.join("\n", messages.stream()
-                            .map(PlainTextFormatter::formatPost).collect(Collectors.toList()))));
+                            .map(PlainTextFormatter::formatPost).collect(Collectors.toList())));
         }
-        return new ProtocolReply("User not found");
+        return "User not found";
     }
 
     @UserCommand(pattern = "^d\\s*\\#([0-9]+)$", patternFlags = Pattern.CASE_INSENSITIVE,
             help = "D #12345 - delete the message")
-    public ProtocolReply commandDel(User user, String... args) {
+    public String commandDel(User user, String... args) {
         int mid = NumberUtils.toInt(args[0], 0);
         if (messagesService.deleteMessage(user.getUid(), mid)) {
-            return new ProtocolReply(String.format("Message %s deleted", mid));
+            return String.format("Message %s deleted", mid);
         }
-        return new ProtocolReply("Error");
+        return "Error";
     }
 
     @UserCommand(pattern = "^login$", patternFlags = Pattern.CASE_INSENSITIVE,
             help = "LOGIN - log in to Juick website")
-    public ProtocolReply commandLogin(User user, String... arguments) {
-        return new ProtocolReply(baseUri + "?" + userService.getHashByUID(user.getUid()));
+    public String commandLogin(User user, String... arguments) {
+        return baseUri + "?" + userService.getHashByUID(user.getUid());
     }
 
     @UserCommand(pattern = "^(#+)$", help = "# - Show last messages from your feed (## - second page, ...)")
-    public ProtocolReply commandMyFeed(User user, String... arguments) {
+    public String commandMyFeed(User user, String... arguments) {
         // number of # is the page count
         int page = arguments[0].length() - 1;
         List<Integer> mids = messagesService.getMyFeed(user.getUid(), page);
         List<Message> messages = messagesService.getMessages(mids);
         // TODO: add instructions for empty feed
-        return new ProtocolReply("Your feed: \n" + String.join("\n",
-                messages.stream().map(PlainTextFormatter::formatPost).collect(Collectors.toList())));
+        return "Your feed: \n" + String.join("\n",
+                messages.stream().map(PlainTextFormatter::formatPost).collect(Collectors.toList()));
     }
 
     @UserCommand(pattern = "^(on|off)$", patternFlags = Pattern.CASE_INSENSITIVE,
             help = "ON/OFF - Enable/disable subscriptions delivery")
-    public ProtocolReply commandOnOff(User user, String[] input) {
+    public String commandOnOff(User user, String[] input) {
         UserService.ActiveStatus newStatus;
         String retValUpdated;
         if (input[0].toLowerCase().equals("on")) {
@@ -275,20 +275,20 @@ public class JuickProtocol {
         }
 
         if (userService.setActiveStatusForJID(user.getJid(), newStatus)) {
-            return new ProtocolReply(retValUpdated);
+            return retValUpdated;
         } else {
-            return new ProtocolReply(String.format("Subscriptions status for %s was not changed", user.getJid()));
+            return String.format("Subscriptions status for %s was not changed", user.getJid());
         }
     }
 
     @UserCommand(pattern = "^ping$", patternFlags = Pattern.CASE_INSENSITIVE,
             help = "PING - returns you a PONG")
-    public ProtocolReply commandPing(User user, String[] input) {
-        return new ProtocolReply("PONG");
+    public String commandPing(User user, String[] input) {
+        return "PONG";
     }
 
     @UserCommand(pattern = "^\\@(\\S+)\\s+([\\s\\S]+)$", help = "@username message - send PM to username")
-    public ProtocolReply commandPM(User user_from, String... arguments) {
+    public String commandPM(User user_from, String... arguments) {
         String user_to = arguments[0];
         String body = arguments[1];
 
@@ -298,121 +298,118 @@ public class JuickProtocol {
             if (!userService.isInBLAny(toUser.getUid(), user_from.getUid())) {
                 if (pmQueriesService.createPM(user_from.getUid(), toUser.getUid(), body)) {
                     listener.privateMessage(user_from, toUser, body);
-                    return new ProtocolReply("Private message sent");
+                    return "Private message sent";
                 }
             }
         }
-        return new ProtocolReply("Error");
+        return "Error";
     }
 
     @UserCommand(pattern = "^#(\\d+)(\\+?)$", help = "#1234 - Show message (#1234+ - message with replies)")
-    public ProtocolReply commandShow(User user, String... arguments) {
+    public String commandShow(User user, String... arguments) {
         boolean showReplies = arguments[1].length() > 0;
-        int mid;
-        try {
-            mid = Integer.parseInt(arguments[0]);
-        } catch (NumberFormatException e) {
-            return new ProtocolReply("Error");
+        int mid = NumberUtils.toInt(arguments[0], 0);
+        if (mid == 0) {
+            return "Error";
         }
         Message msg = messagesService.getMessage(mid);
         if (msg != null) {
             if (showReplies) {
                 List<Message> replies = messagesService.getReplies(mid);
                 replies.add(0, msg);
-                return new ProtocolReply(String.join("\n",
-                        replies.stream().map(PlainTextFormatter::formatPost).collect(Collectors.toList())));
+                return String.join("\n",
+                        replies.stream().map(PlainTextFormatter::formatPost).collect(Collectors.toList()));
             }
-            return new ProtocolReply(PlainTextFormatter.formatPost(msg));
+            return PlainTextFormatter.formatPost(msg);
         }
-        return new ProtocolReply("Message not found");
+        return "Message not found";
     }
     @UserCommand(pattern = "^(#|\\.)(\\d+)((\\.|\\-|\\/)(\\d+))?\\s([\\s\\S]+)",
     help = "#1234 *tag *tag2 - edit tags\n#1234 text - reply to message")
-    public ProtocolReply EditOrReply(User user, String... args) {
+    public String EditOrReply(User user, String... args) {
         int mid = NumberUtils.toInt(args[1]);
         int rid = NumberUtils.toInt(args[4], 0);
         String txt = args[5];
         List<Tag> messageTags = tagService.fromString(txt, true);
         if (messageTags.size() > 0) {
             if (user.getUid() != messagesService.getMessageAuthor(mid).getUid()) {
-                return new ProtocolReply("It is not your message");
+                return "It is not your message";
             }
             tagService.updateTags(mid, messageTags);
-            return new ProtocolReply("Tags are updated");
+            return "Tags are updated";
         } else {
             int newrid = messagesService.createReply(mid, rid, user.getUid(), txt, null);
             listener.messagePosted(messagesService.getReply(mid, newrid));
-            return new ProtocolReply("Reply posted.\n#" + mid + "/" + newrid + " "
-                    + baseUri + mid + "#" + newrid);
+            return "Reply posted.\n#" + mid + "/" + newrid + " "
+                    + baseUri + mid + "#" + newrid;
         }
     }
 
     @UserCommand(pattern = "^(s|u)\\s+#(\\d+)$", help = "S #1234 - subscribe to comments",
             patternFlags = Pattern.CASE_INSENSITIVE)
-    public ProtocolReply commandSubscribeMessage(User user, String... args) {
+    public String commandSubscribeMessage(User user, String... args) {
         boolean subscribe = args[0].equalsIgnoreCase("s");
         int mid = NumberUtils.toInt(args[1], 0);
         if (messagesService.getMessage(mid) != null) {
             if (subscribe) {
                 if (subscriptionService.subscribeMessage(mid, user.getUid())) {
-                    return new ProtocolReply("Subscribed");
+                    return "Subscribed";
                 }
             } else {
                 if (subscriptionService.unSubscribeMessage(mid, user.getUid())) {
-                    return new ProtocolReply("Unsubscribed from #" + mid);
+                    return "Unsubscribed from #" + mid;
                 }
-                return new ProtocolReply("You was not subscribed to #" + mid);
+                return "You was not subscribed to #" + mid;
             }
         }
-        return new ProtocolReply("Error");
+        return "Error";
     }
     @UserCommand(pattern = "^(s|u)\\s+\\@(\\S+)$", help = "S @user - subscribe to user's posts",
             patternFlags = Pattern.CASE_INSENSITIVE)
-    public ProtocolReply commandSubscribeUser(User user, String... args) {
+    public String commandSubscribeUser(User user, String... args) {
         boolean subscribe = args[0].equalsIgnoreCase("s");
         User toUser = userService.getUserByName(args[1]);
         if (toUser.getUid() > 0) {
             if (subscribe) {
                 if (subscriptionService.subscribeUser(user, toUser)) {
                     listener.userSubscribed(user, toUser);
-                    return new ProtocolReply("Subscribed");
+                    return "Subscribed";
                     // TODO: already subscribed case
                 }
             } else {
                 if (subscriptionService.unSubscribeUser(user, toUser)) {
-                    return new ProtocolReply("Unsubscribed from @" + toUser.getName());
+                    return "Unsubscribed from @" + toUser.getName();
                 }
-                return new ProtocolReply("You was not subscribed to @" + toUser.getName());
+                return "You was not subscribed to @" + toUser.getName();
             }
         }
-        return new ProtocolReply("Error");
+        return "Error";
     }
     @UserCommand(pattern = "^(s|u)\\s+\\*(\\S+)$", help = "S *tag - subscribe to tag" +
             "\nU *tag - unsubscribe from tag", patternFlags = Pattern.CASE_INSENSITIVE)
-    public ProtocolReply commandSubscribeTag(User user, String... args) {
+    public String commandSubscribeTag(User user, String... args) {
         boolean subscribe = args[0].equalsIgnoreCase("s");
         Tag tag = tagService.getTag(args[1], true);
         if (subscribe) {
             if (subscriptionService.subscribeTag(user, tag)) {
-                return new ProtocolReply("Subscribed");
+                return "Subscribed";
             }
         } else {
             if (subscriptionService.unSubscribeTag(user, tag)) {
-                return new ProtocolReply("Unsubscribed from " + tag.getName());
+                return "Unsubscribed from " + tag.getName();
             }
-            return new ProtocolReply("You was not subscribed to " + tag.getName());
+            return "You was not subscribed to " + tag.getName();
         }
-        return new ProtocolReply("Error");
+        return "Error";
     }
 
     @UserCommand(pattern = "^help$", patternFlags = Pattern.CASE_INSENSITIVE,
             help = "HELP - returns this help message")
-    public ProtocolReply commandHelp(User user, String[] input) {
-        List<String> commandsHelp = Arrays.stream(getClass().getDeclaredMethods())
+    public String commandHelp(User user, String[] input) {
+        return Arrays.stream(getClass().getDeclaredMethods())
                 .filter(m -> m.isAnnotationPresent(UserCommand.class))
                 .map(m -> m.getAnnotation(UserCommand.class).help())
-                .collect(Collectors.toList());
-        return new ProtocolReply(String.join("\n", commandsHelp));
+                .collect(Collectors.joining("\n"));
     }
 
     public String getBaseUri() {
diff --git a/juick-server/src/main/java/com/juick/server/protocol/ProtocolReply.java b/juick-server/src/main/java/com/juick/server/protocol/ProtocolReply.java
deleted file mode 100644
index f3483187..00000000
--- a/juick-server/src/main/java/com/juick/server/protocol/ProtocolReply.java
+++ /dev/null
@@ -1,16 +0,0 @@
-package com.juick.server.protocol;
-
-/**
- * Created by vitalyster on 08.04.2016.
- */
-public class ProtocolReply {
-
-    private String result;
-
-    public ProtocolReply(String text) {
-        this.result = text;
-    }
-    public String getResult() {
-        return result;
-    }
-}
diff --git a/juick-ws/src/main/java/com/juick/ws/WebsocketComponent.java b/juick-ws/src/main/java/com/juick/ws/WebsocketComponent.java
index 8d0c3d76..bca1b27a 100644
--- a/juick-ws/src/main/java/com/juick/ws/WebsocketComponent.java
+++ b/juick-ws/src/main/java/com/juick/ws/WebsocketComponent.java
@@ -149,7 +149,7 @@ public class WebsocketComponent extends TextWebSocketHandler implements Protocol
             String input = message.getPayload();
             if (StringUtils.isNotBlank(input)) {
                 try {
-                    s.session.sendMessage(new TextMessage(protocol.getReply(user, input).getResult()));
+                    s.session.sendMessage(new TextMessage(protocol.getReply(user, input)));
                 } catch (IOException | InvocationTargetException | IllegalAccessException | NoSuchMethodException e) {
                     logger.error("protocol exception", e);
                 }
diff --git a/juick-xmpp-bot/src/main/java/com/juick/components/XMPPBot.java b/juick-xmpp-bot/src/main/java/com/juick/components/XMPPBot.java
index d5c4c045..916f5029 100644
--- a/juick-xmpp-bot/src/main/java/com/juick/components/XMPPBot.java
+++ b/juick-xmpp-bot/src/main/java/com/juick/components/XMPPBot.java
@@ -4,7 +4,6 @@ import com.juick.User;
 import com.juick.server.helpers.UserInfo;
 import com.juick.server.protocol.JuickProtocol;
 import com.juick.server.protocol.ProtocolListener;
-import com.juick.server.protocol.ProtocolReply;
 import com.juick.service.PMQueriesService;
 import com.juick.service.UserService;
 import org.apache.commons.io.IOUtils;
@@ -81,9 +80,9 @@ public class XMPPBot implements AutoCloseable, ProtocolListener {
                     }
                 } else {
                     try {
-                        ProtocolReply reply = juickProtocol.getReply(user, text);
+                        String reply = juickProtocol.getReply(user, text);
                         Message replyMessage = new Message(message.getFrom(), Message.Type.CHAT);
-                        replyMessage.setBody(reply.getResult());
+                        replyMessage.setBody(reply);
                         replyMessage.setFrom(juickJid);
                         component.send(replyMessage);
                     } catch (InvocationTargetException | IllegalAccessException | NoSuchMethodException ex) {
diff --git a/src/test/java/com/juick/tests/ApiTests.java b/src/test/java/com/juick/tests/ApiTests.java
index 2d09d463..529abd6c 100644
--- a/src/test/java/com/juick/tests/ApiTests.java
+++ b/src/test/java/com/juick/tests/ApiTests.java
@@ -9,7 +9,6 @@ import com.juick.User;
 import com.juick.server.helpers.TagStats;
 import com.juick.server.protocol.JuickProtocol;
 import com.juick.server.protocol.ProtocolListener;
-import com.juick.server.protocol.ProtocolReply;
 import com.juick.service.MessagesService;
 import com.juick.service.SubscriptionService;
 import com.juick.service.TagService;
@@ -198,22 +197,22 @@ public class ApiTests {
         User user = userService.getUserByUID(uid).orElse(new User());
         String expectedMessage = "New message posted";
         assertEquals("should be message", true,
-                juickProtocol.getReply(user, "*yo yoyo").getResult().startsWith(expectedMessage));
+                juickProtocol.getReply(user, "*yo yoyo").startsWith(expectedMessage));
         int mid = messagesService.getUserBlog(user.getUid(), -1, 0).stream().reduce((first, second) -> second).get();
         assertEquals("text should match", "yoyo",
                 messagesService.getMessage(mid).getText());
         assertEquals("tag should match", "yo",
                 tagService.getMessageTags(mid).get(0).getTag().getName());
-        assertNotEquals("should not be error", "Error", juickProtocol.getReply(user, "#" + mid).getResult());
-        assertEquals("should be PONG", "PONG", juickProtocol.getReply(user, "   ping   \n    ").getResult());
+        assertNotEquals("should not be error", "Error", juickProtocol.getReply(user, "#" + mid));
+        assertEquals("should be PONG", "PONG", juickProtocol.getReply(user, "ping"));
         int readerUid = userService.createUser("dummyReader", "dummySecret");
         User readerUser = userService.getUserByUID(readerUid).orElse(new User());
         assertEquals("should be subscribed", "Subscribed",
-                juickProtocol.getReply(readerUser, "S #" + mid).getResult());
+                juickProtocol.getReply(readerUser, "S #" + mid));
         assertEquals("number of subscribed users should match", 1,
                 subscriptionService.getUsersSubscribedToComments(mid, uid).size());
         assertEquals("should be subscribed", "Subscribed",
-                juickProtocol.getReply(readerUser, "S @" + user.getName()).getResult());
+                juickProtocol.getReply(readerUser, "S @" + user.getName()));
         List<User> friends = userService.getUserFriends(readerUid);
         assertEquals("number of friend users should match", 2,
                 friends.size());
@@ -224,54 +223,54 @@ public class ApiTests {
         String expectedSecondReply = "Reply posted.\n#" + mid + "/2 "
                 + juickProtocol.getBaseUri() + mid + "#2";
         assertEquals("should be reply", expectedReply,
-                juickProtocol.getReply(user, "#" + mid + " yoyo").getResult());
+                juickProtocol.getReply(user, "#" + mid + " yoyo"));
         assertEquals("should be second reply", expectedSecondReply,
-                juickProtocol.getReply(user, "#" + mid + "/1 yoyo").getResult());
+                juickProtocol.getReply(user, "#" + mid + "/1 yoyo"));
         Message reply = messagesService.getReplies(mid).stream().filter(m -> m.getRid() == 2).findFirst()
                 .orElse(new Message());
         assertEquals("should be reply to first comment", 1, reply.getReplyto());
         assertNotEquals("tags should NOT be updated", "Tags are updated",
-                juickProtocol.getReply(readerUser, "#" + mid + " *yo *there").getResult());
+                juickProtocol.getReply(readerUser, "#" + mid + " *yo *there"));
         assertEquals("tags should be updated", "Tags are updated",
-                juickProtocol.getReply(user, "#" + mid + " *there").getResult());
+                juickProtocol.getReply(user, "#" + mid + " *there"));
         assertEquals("number of tags should match", 2,
                 tagService.getMessageTags(mid).size());
         assertEquals("should be blacklisted", "Tag added to your blacklist",
-                juickProtocol.getReply(readerUser, "BL *there").getResult());
+                juickProtocol.getReply(readerUser, "BL *there"));
         assertEquals("number of subscribed users should match", 0,
                 subscriptionService.getSubscribedUsers(uid, mid).size());
         assertEquals("tags should be updated", "Tags are updated",
-                juickProtocol.getReply(user, "#" + mid + " *there").getResult());
+                juickProtocol.getReply(user, "#" + mid + " *there"));
         assertEquals("number of tags should match", 1,
                 tagService.getMessageTags(mid).size());
         int taggerUid = userService.createUser("dummyTagger", "dummySecret");
         User taggerUser = userService.getUserByUID(taggerUid).orElse(new User());
         assertEquals("should be subscribed", "Subscribed",
-                juickProtocol.getReply(taggerUser, "S *yo").getResult());
+                juickProtocol.getReply(taggerUser, "S *yo"));
         assertEquals("number of subscribed users should match", 2,
                 subscriptionService.getSubscribedUsers(uid, mid).size());
         assertEquals("should be unsubscribed", "Unsubscribed from yo",
-                juickProtocol.getReply(taggerUser, "U *yo").getResult());
+                juickProtocol.getReply(taggerUser, "U *yo"));
         assertEquals("number of subscribed users should match", 1,
                 subscriptionService.getSubscribedUsers(uid, mid).size());
         assertEquals("number of readers should match", 1,
                 userService.getUserReaders(uid).size());
-        ProtocolReply readerFeed = juickProtocol.getReply(readerUser, "#");
-        assertEquals("description should match", true, readerFeed.getResult().startsWith("Your feed"));
+        String readerFeed = juickProtocol.getReply(readerUser, "#");
+        assertEquals("description should match", true, readerFeed.startsWith("Your feed"));
         assertEquals("should be unsubscribed", "Unsubscribed from @" + user.getName(),
-                juickProtocol.getReply(readerUser, "U @" + user.getName()).getResult());
+                juickProtocol.getReply(readerUser, "U @" + user.getName()));
         assertEquals("number of readers should match", 0,
                 userService.getUserReaders(uid).size());
         assertEquals("number of friends should match", 1,
                 userService.getUserFriends(uid).size());
         assertEquals("should be unsubscribed", "Unsubscribed from #" + mid,
-                juickProtocol.getReply(readerUser, "u #" + mid).getResult());
+                juickProtocol.getReply(readerUser, "u #" + mid));
         assertEquals("number of subscribed users should match", 0,
                 subscriptionService.getUsersSubscribedToComments(mid, uid).size());
         assertNotEquals("should NOT be deleted", String.format("Message %s deleted", mid),
-                juickProtocol.getReply(readerUser, "D #" + mid).getResult());
+                juickProtocol.getReply(readerUser, "D #" + mid));
         assertEquals("should be deleted", String.format("Message %s deleted", mid),
-                juickProtocol.getReply(user, "D #" + mid).getResult());
+                juickProtocol.getReply(user, "D #" + mid));
         assertEquals("should not have messages", 0, messagesService.getAll(user.getUid(), 0).size());
     }