Refactoring

1 files changed, 98 insertions, 115 deletions

diff --git a/src/test/java/com/juick/server/tests/ServerTests.java b/src/test/java/com/juick/server/tests/ServerTests.java
index be077e00..c554f20e 100644
--- a/src/test/java/com/juick/server/tests/ServerTests.java
+++ b/src/test/java/com/juick/server/tests/ServerTests.java
@@ -252,12 +252,9 @@ public class ServerTests {
             freefdPassword = "MyPassw0rd!";
             juickName = "juick";
             juickPassword = "demo";
-            int ugnichId = userService.createUser(ugnichName, ugnichPassword);
-            ugnich = userService.getUserByUID(ugnichId).orElseThrow(IllegalStateException::new);
-            int freefdId = userService.createUser(freefdName, freefdPassword);
-            freefd = userService.getUserByUID(freefdId).orElseThrow(IllegalStateException::new);
-            int juickId = userService.createUser(juickName, juickPassword);
-            juick = userService.getUserByUID(juickId).orElseThrow(IllegalStateException::new);
+            ugnich = userService.createUser(ugnichName, ugnichPassword).orElseThrow(IllegalStateException::new);
+            freefd = userService.createUser(freefdName, freefdPassword).orElseThrow(IllegalStateException::new);
+            juick = userService.createUser(juickName, juickPassword).orElseThrow(IllegalStateException::new);
             webClient.getOptions().setJavaScriptEnabled(false);
             isSetUp = true;
         }
@@ -278,8 +275,8 @@ public class ServerTests {
         int mid2 = messagesService.createMessage(ugnich.getUid(), "test2", null, null);
         List<Integer> freefdFeed = messagesService.getMyFeed(freefd.getUid(), 0, false);
         assertThat(freefdFeed.get(0), equalTo(mid2));
-        int tonyaid = userService.createUser("Tonya", "secret");
-        int mid3 = messagesService.createMessage(tonyaid, "test3", null, null);
+        User tonya = userService.createUser("Tonya", "secret").orElseThrow(IllegalStateException::new);;
+        int mid3 = messagesService.createMessage(tonya.getUid(), "test3", null, null);
         messagesService.recommendMessage(mid3, ugnich.getUid());
         assertThat(messagesService.getMyFeed(freefd.getUid(), 0, false).get(0), equalTo(mid2));
         assertThat(messagesService.getMyFeed(freefd.getUid(), 0, true).get(0), equalTo(mid3));
@@ -328,10 +325,9 @@ public class ServerTests {
 
     @Test
     public void messageTests() {
-        int user_id = userService.createUser("mmmme", "secret");
-        User user = userService.getUserByUID(user_id).orElse(AnonymousUser.INSTANCE);
+        User user = userService.createUser("mmmme", "secret").orElseThrow(IllegalStateException::new);;
         assertEquals("it should be me", "mmmme", user.getName());
-        int mid = messagesService.createMessage(user_id, "yo", null, new ArrayList<>());
+        int mid = messagesService.createMessage(user.getUid(), "yo", null, new ArrayList<>());
         Message msg = messagesService.getMessage(mid).get();
         assertEquals("yo", msg.getText());
         User me = msg.getUser();
@@ -341,13 +337,12 @@ public class ServerTests {
         Tag tag = tagService.getTag(tagID);
         List<Tag> tagList = new ArrayList<>();
         tagList.add(tag);
-        int mid2 = messagesService.createMessage(user_id, "yo2", null, tagList);
+        int mid2 = messagesService.createMessage(user.getUid(), "yo2", null, tagList);
         Message msg2 = messagesService.getMessage(mid2).get();
         assertEquals(1, msg2.getTags().size());
-        assertEquals("we already have ugnich", -1, userService.createUser("ugnich", "x"));
-        int ugnich_id = userService.createUser("hugnich", "x");
-        User ugnich = userService.getUserByUID(ugnich_id).orElse(AnonymousUser.INSTANCE);
-        int rid = messagesService.createReply(msg2.getMid(), 0, ugnich, "bla-bla", null);
+        assertEquals("we already have ugnich", Optional.empty(), userService.createUser("ugnich", "x"));
+        User hugnich = userService.createUser("hugnich", "x").orElseThrow(IllegalStateException::new);;
+        int rid = messagesService.createReply(msg2.getMid(), 0, hugnich, "bla-bla", null);
         assertEquals(1, rid);
         assertThat(msg2.getTo(), equalTo(AnonymousUser.INSTANCE));
         Message reply = messagesService.getReply(msg2.getMid(), rid);
@@ -355,7 +350,7 @@ public class ServerTests {
         List<Message> replies = messagesService.getReplies(user, msg2.getMid());
         assertThat(replies.size(), equalTo(1));
         assertThat(replies.get(0), equalTo(reply));
-        int ridToReply = messagesService.createReply(msg2.getMid(), 1, ugnich, "blax2", null);
+        int ridToReply = messagesService.createReply(msg2.getMid(), 1, hugnich, "blax2", null);
         Message reply2 = messagesService.getReply(msg2.getMid(), ridToReply);
         assertThat(reply.getTo().getName(), equalTo(user.getName()));
         List<Message> replies2 = messagesService.getReplies(user, msg2.getMid());
@@ -366,8 +361,8 @@ public class ServerTests {
 
         assertEquals(2, msg3.getReplies());
         assertEquals("weather", msg3.getTags().stream().findFirst().get().getName());
-        assertEquals(ugnich.getUid(), userService.checkPassword(ugnich.getName(), "x"));
-        assertEquals(-1, userService.checkPassword(ugnich.getName(), "xy"));
+        assertThat(hugnich, is(userService.checkPassword(hugnich.getName(), "x").get()));
+        assertThat(userService.checkPassword(hugnich.getName(), "xy"), is(Optional.empty()));
 
         subscriptionService.subscribeMessage(msg, user);
         subscriptionService.subscribeMessage(msg, ugnich);
@@ -376,26 +371,26 @@ public class ServerTests {
                 messagesService.getReply(msg.getMid(), reply_id)).size());
         assertThat(messagesService.getDiscussions(ugnich.getUid(), 0L).get(0),
                 equalTo(msg.getMid()));
-        messagesService.deleteMessage(user_id, mid);
-        messagesService.deleteMessage(user_id, mid2);
+        messagesService.deleteMessage(user.getUid(), mid);
+        messagesService.deleteMessage(user.getUid(), mid2);
         String htmlTagName = ">_<";
         Tag htmlTag = tagService.getTag(htmlTagName, true);
         TagStats htmlTagStats = new TagStats();
         htmlTagStats.setTag(htmlTag);
         String dbTagName = jdbcTemplate.queryForObject("select name from tags where name=?", String.class, htmlTagName);
         assertEquals("db tags should not be escaped", dbTagName, htmlTag.getName());
-        int mid4 = messagesService.createMessage(user_id, "yoyoyo", null, null);
+        int mid4 = messagesService.createMessage(user.getUid(), "yoyoyo", null, null);
         Message msg4 = messagesService.getMessage(mid4).get();
         assertEquals("tags string should be empty", StringUtils.EMPTY, MessageUtils.getTagsString(msg4));
-        messagesService.deleteMessage(user_id, mid4);
+        messagesService.deleteMessage(user.getUid(), mid4);
     }
     public ExpectedException exception = ExpectedException.none();
 
     @Test
     public void likeTypeStatsTests(){
-        int user_id = userService.createUser("dsdss", "secret");
+        User dsdss = userService.createUser("dsdss", "secret").orElseThrow(IllegalStateException::new);;
         final int freefdId = freefd.getUid();
-        int mid = messagesService.createMessage(user_id, "yo", null, new ArrayList<>());
+        int mid = messagesService.createMessage(dsdss.getUid(), "yo", null, new ArrayList<>());
         messagesService.likeMessage(mid, freefdId , 2);
         messagesService.likeMessage(mid, freefdId,2);
         messagesService.likeMessage(mid, freefdId,3);
@@ -411,24 +406,24 @@ public class ServerTests {
     }
     @Test
     public void lastJidShouldNotBeDeleted() {
-        int ugnich_id = userService.createUser("hugnich2", "x");
-        jdbcTemplate.update("INSERT INTO jids(user_id,jid,active) VALUES(?,?,?)", ugnich_id, "firstjid@localhost", 1);
-        jdbcTemplate.update("INSERT INTO jids(user_id,jid,active) VALUES(?,?,?)", ugnich_id, "secondjid@localhost", 1);
-        assertThat(userService.deleteJID(ugnich_id, "secondjid@localhost"), equalTo(true));
-        assertThat(userService.deleteJID(ugnich_id, "firstjid@localhost"), equalTo(false));
+        User hugnich2 = userService.createUser("hugnich2", "x").orElseThrow(IllegalStateException::new);;
+        jdbcTemplate.update("INSERT INTO jids(user_id,jid,active) VALUES(?,?,?)", hugnich2.getUid(), "firstjid@localhost", 1);
+        jdbcTemplate.update("INSERT INTO jids(user_id,jid,active) VALUES(?,?,?)", hugnich2.getUid(), "secondjid@localhost", 1);
+        assertThat(userService.deleteJID(hugnich2.getUid(), "secondjid@localhost"), equalTo(true));
+        assertThat(userService.deleteJID(hugnich2.getUid(), "firstjid@localhost"), equalTo(false));
     }
     @Test
     public void lastEmailShouldNotBeDeleted() {
-        int ugnich_id = userService.createUser("hugnich3", "x");
-        jdbcTemplate.update("INSERT INTO emails(user_id,email) VALUES(?,?)", ugnich_id, "first@localhost");
-        jdbcTemplate.update("INSERT INTO emails(user_id,email) VALUES(?,?)", ugnich_id, "second@localhost");
-        assertThat(emailService.deleteEmail(ugnich_id, "second@localhost"), equalTo(true));
-        assertThat(emailService.deleteEmail(ugnich_id, "first@localhost"), equalTo(false));
+        User hugnich3 = userService.createUser("hugnich3", "x").orElseThrow(IllegalStateException::new);;
+        jdbcTemplate.update("INSERT INTO emails(user_id,email) VALUES(?,?)", hugnich3.getUid(), "first@localhost");
+        jdbcTemplate.update("INSERT INTO emails(user_id,email) VALUES(?,?)", hugnich3.getUid(), "second@localhost");
+        assertThat(emailService.deleteEmail(hugnich3.getUid(), "second@localhost"), equalTo(true));
+        assertThat(emailService.deleteEmail(hugnich3.getUid(), "first@localhost"), equalTo(false));
     }
     @Test
     public void messageUpdatedTimeShouldMatchLastReplyTime() throws InterruptedException {
-        int ugnich_id = userService.createUser("hugnich4", "x");
-        int mid = messagesService.createMessage(ugnich_id, "yo", null, null);
+        User hugnich4 = userService.createUser("hugnich4", "x").orElseThrow(IllegalStateException::new);;
+        int mid = messagesService.createMessage(hugnich4.getUid(), "yo", null, null);
         Instant ts = jdbcTemplate.queryForObject("SELECT updated FROM messages WHERE message_id=?",
                 Timestamp.class, mid).toInstant();
         Thread.sleep(1000);
@@ -438,7 +433,7 @@ public class ServerTests {
         assertThat(rts, greaterThan(ts));
         Message msg = messagesService.getReply(mid, rid);
         assertThat(rts, equalTo(msg.getCreated()));
-        messagesService.deleteMessage(ugnich_id, mid);
+        messagesService.deleteMessage(hugnich4.getUid(), mid);
     }
 
     @Test
@@ -544,13 +539,12 @@ public class ServerTests {
 
     @Test
     public void messagesUrlTest() throws Exception {
-        int user_id = userService.createUser("dsds4345", "secret");
+        User dsds4345 = userService.createUser("dsds4345", "secret").orElseThrow(IllegalStateException::new);;
 
         String freefdHash = userService.getHashByUID(freefd.getUid());
-        System.out.println("user_id"+ user_id);
-        String userIdHash = userService.getHashByUID(user_id);
+        String userIdHash = userService.getHashByUID(dsds4345.getUid());
         final int freefdId = freefd.getUid();
-        int mid = messagesService.createMessage(user_id, "yo", null, new ArrayList<>());
+        int mid = messagesService.createMessage(dsds4345.getUid(), "yo", null, new ArrayList<>());
         messagesService.likeMessage(mid, freefdId, 2 );
         messagesService.likeMessage(mid, freefdId, 2 );
         messagesService.likeMessage(mid, freefdId, 3 );
@@ -715,8 +709,7 @@ public class ServerTests {
 
     @Test
     public void protocolTests() throws Exception {
-        int uid = userService.createUser("me", "secret");
-        User user = userService.getUserByUID(uid).orElse(AnonymousUser.INSTANCE);
+        User user = userService.createUser("me", "secret").orElseThrow(IllegalStateException::new);;
         Tag yo = tagService.getTag("yo", true);
         Message msg = commandsManager.processCommand(user, "*yo yoyo", URI.create("https://static.juick.com/settings/facebook.png")).getNewMessage().get();
         assertThat(msg.getAttachmentType(), is("png"));
@@ -735,8 +728,7 @@ public class ServerTests {
         assertThat(last.toInstant(), equalTo(yoyoMsg.getNewMessage().get().getCreated()));
         assertEquals("should be message", true,
                 commandsManager.processCommand(user, String.format("#%d", mid), emptyUri).getText().startsWith("@me"));
-        int readerUid = userService.createUser("dummyReader", "dummySecret");
-        User readerUser = userService.getUserByUID(readerUid).orElse(AnonymousUser.INSTANCE);
+        User readerUser = userService.createUser("dummyReader", "dummySecret").orElseThrow(IllegalStateException::new);;
         assertThat(commandsManager.processCommand(readerUser, "s", emptyUri).getText().startsWith("You are subscribed to"), is(true));
         assertThat(commandsManager.processCommand(readerUser, "S", emptyUri).getText().startsWith("You are subscribed to"), is(true));
         assertEquals("should be subscribed", "Subscribed",
@@ -760,11 +752,11 @@ public class ServerTests {
         assertEquals("should be subscribed", "Subscribed to @" + user.getName(),
                 commandsManager.processCommand(readerUser, "S @" + user.getName(), emptyUri)
                         .getText());
-        List<User> friends = userService.getUserFriends(readerUid);
+        List<User> friends = userService.getUserFriends(readerUser.getUid());
         assertEquals("number of friend users should match", 2,
                 friends.size());
         assertEquals("number of reader users should match", 1,
-                userService.getUserReaders(uid).size());
+                userService.getUserReaders(user.getUid()).size());
         String expectedSecondReply = "Reply posted.\n#" + mid + "/2 "
                 + "https://juick.com/m/" + mid + "#2";
         String expectedThirdReply = "Reply posted.\n#" + mid + "/3 "
@@ -789,32 +781,31 @@ public class ServerTests {
         assertEquals("should be blacklisted", "Tag added to your blacklist",
                 commandsManager.processCommand(readerUser, "BL *there", emptyUri).getText());
         assertEquals("number of subscribed users should match", 0,
-                subscriptionService.getSubscribedUsers(uid, msg2).size());
+                subscriptionService.getSubscribedUsers(user.getUid(), msg2).size());
         assertEquals("tags should be updated", "Tags are updated",
                 commandsManager.processCommand(user, "#" + mid + " *there", emptyUri).getText());
         assertEquals("number of tags should match", 1,
                 tagService.getMessageTags(mid).size());
-        int taggerUid = userService.createUser("dummyTagger", "dummySecret");
-        User taggerUser = userService.getUserByUID(taggerUid).orElse(AnonymousUser.INSTANCE);
+        User taggerUser = userService.createUser("dummyTagger", "dummySecret").orElseThrow(IllegalStateException::new);;
         assertEquals("should be subscribed", "Subscribed",
                 commandsManager.processCommand(taggerUser, "S *yo", emptyUri).getText());
         assertEquals("number of subscribed users should match", 2,
-                subscriptionService.getSubscribedUsers(uid, msg2).size());
+                subscriptionService.getSubscribedUsers(user.getUid(), msg2).size());
         assertEquals("should be unsubscribed", "Unsubscribed from yo",
                 commandsManager.processCommand(taggerUser, "U *yo", emptyUri).getText());
         assertEquals("number of subscribed users should match", 1,
-                subscriptionService.getSubscribedUsers(uid, msg2).size());
+                subscriptionService.getSubscribedUsers(user.getUid(), msg2).size());
         assertEquals("number of readers should match", 1,
-                userService.getUserReaders(uid).size());
+                userService.getUserReaders(user.getUid()).size());
         String readerFeed = commandsManager.processCommand(readerUser, "#", emptyUri).getText();
         assertTrue("description should match", readerFeed.startsWith("Your feed"));
         assertEquals("should be unsubscribed", "Unsubscribed from @" + user.getName(),
                 commandsManager.processCommand(readerUser, "U @" + user.getName(), emptyUri)
                         .getText());
         assertEquals("number of readers should match", 0,
-                userService.getUserReaders(uid).size());
+                userService.getUserReaders(user.getUid()).size());
         assertEquals("number of friends should match", 1,
-                userService.getUserFriends(uid).size());
+                userService.getUserFriends(user.getUid()).size());
         assertEquals("should be unsubscribed", "Unsubscribed from #" + mid,
                 commandsManager.processCommand(readerUser, "u #" + mid, emptyUri).getText());
         assertEquals("number of subscribed users should match", 0,
@@ -915,9 +906,9 @@ public class ServerTests {
 
     @Test
     public void likesTests() throws Exception{
-         int user_id = userService.createUser("dsds", "secret");
+         User dsds = userService.createUser("dsds", "secret").orElseThrow(IllegalStateException::new);;
          String freefdHash = userService.getHashByUID(freefd.getUid());
-         int mid1 = messagesService.createMessage(user_id, "yo", null, new ArrayList<>());
+         int mid1 = messagesService.createMessage(dsds.getUid(), "yo", null, new ArrayList<>());
 
          mockMvc.perform(post("/api/react?mid=" + mid1 + "&hash=" + freefdHash+ "&reactionId=2"))
                  .andExpect(status().isOk());
@@ -995,14 +986,14 @@ public class ServerTests {
                 .stream().noneMatch(m -> m.getTags().contains(banned)));
         assertTrue(messagesService.getMessages(AnonymousUser.INSTANCE, messagesService.getMyFeed(freefd.getUid(), 0, true))
                 .stream().noneMatch(m -> m.getTags().contains(banned)));
-        int newUid = userService.createUser("newUser1", "12345");
-        int newMid = messagesService.createMessage(newUid, "people", null, Collections.singletonList(banned));
+        User newUser1 = userService.createUser("newUser1", "12345").orElseThrow(IllegalStateException::new);;
+        int newMid = messagesService.createMessage(newUser1.getUid(), "people", null, Collections.singletonList(banned));
         messagesService.recommendMessage(newMid, ugnich.getUid());
         assertTrue(messagesService.getMessages(AnonymousUser.INSTANCE, messagesService.getMyFeed(freefd.getUid(), 0, true))
                 .stream().noneMatch(m -> m.getTags().contains(banned)));
         tagService.updateTags(newMid, Collections.singletonList(banned));
         assertThat(messagesService.getMessage(newMid).get().getTags().size(), is(0));
-        privacyQueriesService.blacklistUser(freefd, userService.getUserByUID(newUid).orElse(AnonymousUser.INSTANCE));
+        privacyQueriesService.blacklistUser(freefd, newUser1);
         assertTrue(messagesService.getMyFeed(freefd.getUid(), 0, true)
                 .stream().noneMatch(m -> m == newMid));
     }
@@ -1252,47 +1243,41 @@ public class ServerTests {
     }
     @Test
     public void subscribersToRecommendations() {
-        int readerId = userService.createUser("reader", "123456");
-        int recommenderId = userService.createUser("recommender", "123456");
-        int lateRecommenderId = userService.createUser("lateRecommender", "123456");
-        int posterId = userService.createUser("poster", "123456");
-        User reader = userService.getUserByName("reader");
-        User recommender = userService.getUserByName("recommender");
-        User lateRecommender = userService.getUserByName("lateRecommender");
-        User poster = userService.getUserByName("poster");
+        User reader = userService.createUser("reader", "123456").orElseThrow(IllegalStateException::new);;
+        User recommender = userService.createUser("recommender", "123456").orElseThrow(IllegalStateException::new);;
+        User lateRecommender = userService.createUser("lateRecommender", "123456").orElseThrow(IllegalStateException::new);;
+        User poster = userService.createUser("poster", "123456").orElseThrow(IllegalStateException::new);;
         subscriptionService.subscribeUser(reader, recommender);
         subscriptionService.subscribeUser(reader, lateRecommender);
         Tag sampleTag = tagService.getTag("banned", true);
-        int posterMid = messagesService.createMessage(posterId, "YO", null, Collections.singletonList(sampleTag));
-        messagesService.recommendMessage(posterMid, recommenderId);
+        int posterMid = messagesService.createMessage(poster.getUid(), "YO", null, Collections.singletonList(sampleTag));
+        messagesService.recommendMessage(posterMid, recommender.getUid());
         BiFunction<Integer, Message, List<User>> subscribers = (recommId, msg) ->
                 subscriptionService.getUsersSubscribedToUserRecommendations(recommId, msg);
-        List<User> recommendSubscribers = subscribers.apply(recommenderId, messagesService.getMessage(posterMid).get());
+        List<User> recommendSubscribers = subscribers.apply(recommender.getUid(), messagesService.getMessage(posterMid).get());
         assertThat(recommendSubscribers.size(), is(1));
-        assertThat(recommendSubscribers.get(0).getUid(), is(readerId));
+        assertThat(recommendSubscribers.get(0).getUid(), is(reader.getUid()));
         privacyQueriesService.blacklistUser(reader, poster);
-        assertThat(subscribers.apply(recommenderId, messagesService.getMessage(posterMid).get()).size(), is(0));
+        assertThat(subscribers.apply(recommender.getUid(), messagesService.getMessage(posterMid).get()).size(), is(0));
         privacyQueriesService.blacklistUser(reader, poster);
-        assertThat(subscribers.apply(recommenderId, messagesService.getMessage(posterMid).get()).size(), is(1));
+        assertThat(subscribers.apply(recommender.getUid(), messagesService.getMessage(posterMid).get()).size(), is(1));
         tagService.blacklistTag(reader, sampleTag);
-        assertThat(subscribers.apply(recommenderId, messagesService.getMessage(posterMid).get()).size(), is(0));
+        assertThat(subscribers.apply(recommender.getUid(), messagesService.getMessage(posterMid).get()).size(), is(0));
         tagService.blacklistTag(reader, sampleTag);
-        assertThat(subscribers.apply(recommenderId, messagesService.getMessage(posterMid).get()).size(), is(1));
-        messagesService.recommendMessage(posterMid, lateRecommenderId);
-        List<User> lateRecommendSubscribers = subscribers.apply(recommenderId, messagesService.getMessage(posterMid).get());
+        assertThat(subscribers.apply(recommender.getUid(), messagesService.getMessage(posterMid).get()).size(), is(1));
+        messagesService.recommendMessage(posterMid, lateRecommender.getUid());
+        List<User> lateRecommendSubscribers = subscribers.apply(recommender.getUid(), messagesService.getMessage(posterMid).get());
         assertThat(lateRecommendSubscribers.size(), is(0));
-        int readerMid = messagesService.createMessage(readerId, "PEOPLE", null, null);
-        messagesService.recommendMessage(readerMid, recommenderId);
-        assertThat(subscribers.apply(recommenderId, messagesService.getMessage(readerMid).get()).size(), is(0));
+        int readerMid = messagesService.createMessage(reader.getUid(), "PEOPLE", null, null);
+        messagesService.recommendMessage(readerMid, recommender.getUid());
+        assertThat(subscribers.apply(recommender.getUid(), messagesService.getMessage(readerMid).get()).size(), is(0));
     }
     @Test
     public void mentionsInComments() {
-        int posterId = userService.createUser("p", "secret");
-        int commenterId = userService.createUser("cc", "secret");
-        User commenter = userService.getUserByUID(commenterId).get();
-        int mentionerId = userService.createUser("mmm", "secret");
-        User mentioner = userService.getUserByUID(mentionerId).get();
-        int mid = messagesService.createMessage(posterId, "who is dick?", null, null);
+        User poster = userService.createUser("p", "secret").orElseThrow(IllegalStateException::new);;
+        User commenter = userService.createUser("cc", "secret").orElseThrow(IllegalStateException::new);;
+        User mentioner = userService.createUser("mmm", "secret").orElseThrow(IllegalStateException::new);;
+        int mid = messagesService.createMessage(poster.getUid(), "who is dick?", null, null);
         Message msg = messagesService.getMessage(mid).get();
         int rid = messagesService.createReply(mid, 0, commenter,
                 "@mmm is dick", null);
@@ -1305,8 +1290,7 @@ public class ServerTests {
     }
     @Test
     public void credentialsShouldNeverBeSerialized() throws Exception {
-        int uid = userService.createUser("yyy", "xxxx");
-        User yyy = userService.getUserByUID(uid).get();
+        User yyy = userService.createUser("yyy", "xxxx").orElseThrow(IllegalStateException::new);;
         assertThat(yyy.getCredentials(), is("xxxx"));
         ObjectMapper jsonMapper = new ObjectMapper();
         jsonMapper.setSerializationInclusion(JsonInclude.Include.NON_DEFAULT);
@@ -1336,7 +1320,7 @@ public class ServerTests {
         String userPassword = "secret";
         String msgText = "автор этого поста был забанен";
 
-        User isilmine = userService.getUserByUID(userService.createUser(userName, userPassword)).orElseThrow(IllegalStateException::new);
+        User isilmine = userService.createUser(userName, userPassword).orElseThrow(IllegalStateException::new);
         int mid = messagesService.createMessage(isilmine.getUid(), msgText, null, null);
         mockMvc.perform(get(String.format("/api/thread?mid=%d", mid)).with(httpBasic(ugnichName, ugnichPassword)))
                 .andExpect(status().isOk());
@@ -1367,14 +1351,14 @@ public class ServerTests {
     @Test
     public void bannedUserShouldBeShadowedFromRecommendationsList() throws IOException {
         jdbcTemplate.execute("DELETE FROM bl_users");
-        int ermineId = userService.createUser("ermine", "secret");
-        int monstreekId = userService.createUser("monstreek", "secret");
-        int pogoId = userService.createUser("pogo", "secret");
-        int fmapId = userService.createUser("fmap", "secret");
-        int mid = messagesService.createMessage(monstreekId, "KURWA", null, null);
-        assertThat(messagesService.recommendMessage(mid, ermineId), is(MessagesService.RecommendStatus.Added));
-        assertThat(messagesService.recommendMessage(mid, fmapId), is(MessagesService.RecommendStatus.Added));
-        assertThat(messagesService.recommendMessage(mid, pogoId), is(MessagesService.RecommendStatus.Added));
+        User ermine = userService.createUser("ermine", "secret").orElseThrow(IllegalStateException::new);;
+        User monstreek = userService.createUser("monstreek", "secret").orElseThrow(IllegalStateException::new);;
+        User pogo = userService.createUser("pogo", "secret").orElseThrow(IllegalStateException::new);;
+        User fmap = userService.createUser("fmap", "secret").orElseThrow(IllegalStateException::new);;
+        int mid = messagesService.createMessage(monstreek.getUid(), "KURWA", null, null);
+        assertThat(messagesService.recommendMessage(mid, ermine.getUid()), is(MessagesService.RecommendStatus.Added));
+        assertThat(messagesService.recommendMessage(mid, fmap.getUid()), is(MessagesService.RecommendStatus.Added));
+        assertThat(messagesService.recommendMessage(mid, pogo.getUid()), is(MessagesService.RecommendStatus.Added));
         jdbcTemplate.update("INSERT INTO favorites(user_id, user_uri, message_id, like_id, ts) " +
                 "values (0, 'http://example.com/u/test', ?, 1, now())", mid);
         assertThat(messagesService.getMessage(mid).get().getLikes(), is(4));
@@ -1393,15 +1377,15 @@ public class ServerTests {
     @Test
     public void bannedUserShouldNotBeVisibleToOthers() {
         jdbcTemplate.execute("DELETE FROM messages");
-        int casualUserId = userService.createUser("user", "secret");
-        int bannedUserId = userService.createUser("banned", "banned");
-        jdbcTemplate.update("UPDATE users SET banned=1 WHERE id=?", bannedUserId);
-        messagesService.createMessage(bannedUserId, "KURWA", null, Collections.emptyList());
-        assertThat(messagesService.getAll(casualUserId, 0).size(), is(0));
-        assertThat(messagesService.getDiscussions(casualUserId, 0L).size(), is(0));
+        User casualUser = userService.createUser("user", "secret").orElseThrow(IllegalStateException::new);;
+        User bannedUser = userService.createUser("banned", "banned").orElseThrow(IllegalStateException::new);;
+        jdbcTemplate.update("UPDATE users SET banned=1 WHERE id=?", bannedUser.getUid());
+        messagesService.createMessage(bannedUser.getUid(), "KURWA", null, Collections.emptyList());
+        assertThat(messagesService.getAll(casualUser.getUid(), 0).size(), is(0));
+        assertThat(messagesService.getDiscussions(casualUser.getUid(), 0L).size(), is(0));
         assertThat(messagesService.getDiscussions(0, 0L).size(), is(0));
-        assertThat(messagesService.getAll(bannedUserId, 0).size(), is(1));
-        int mid = messagesService.createMessage(casualUserId, "PEACE", null, Collections.emptyList());
+        assertThat(messagesService.getAll(bannedUser.getUid(), 0).size(), is(1));
+        int mid = messagesService.createMessage(casualUser.getUid(), "PEACE", null, Collections.emptyList());
         User banned = userService.getUserByName("banned");
         int bannedRid = messagesService.createReply(mid, 0, banned, "KURWA", null);
         int casualRid = messagesService.createReply(mid, 0, userService.getUserByName("user"), "DOOR", null);
@@ -1482,9 +1466,8 @@ public class ServerTests {
         assertThat(threadPage.querySelectorAll(".a-thread-comment").isEmpty(), equalTo(false));
         privacyQueriesService.blacklistUser(freefd, ugnich);
         assertThat(userService.isInBLAny(freefd.getUid(), ugnich.getUid()), equalTo(true));
-        int renhaId = userService.createUser("renha", "secret");
-        messagesService.createReply(mid, 0, userService.getUserByUID(renhaId).orElseThrow(IllegalStateException::new),
-                "people", null);
+        User renha = userService.createUser("renha", "secret").orElseThrow(IllegalStateException::new);
+        messagesService.createReply(mid, 0, renha,"people", null);
         threadPage = webClient.getPage(String.format("http://localhost:8080/ugnich/%d", mid));
         assertThat(threadPage.getWebResponse().getStatusCode(), equalTo(200));
         assertThat(threadPage.querySelectorAll(".msg-comment-target").isEmpty(), equalTo(true));
@@ -1833,11 +1816,11 @@ public class ServerTests {
     @Test
     public void seenTests() {
         Instant now = Instant.now();
-        int newUserUid = userService.createUser("newuser", "assword");
-        assertThat(newUserUid, greaterThanOrEqualTo(0));
-        assertThat(userService.getUserByUID(newUserUid).get().getSeen(), is(nullValue()));
-        messagesService.createMessage(newUserUid, "YO", "", null);
-        assertThat(userService.getUserByUID(newUserUid).get().getSeen(), greaterThanOrEqualTo(now));
+        User newUser = userService.createUser("newuser", "assword").orElseThrow(IllegalStateException::new);;
+        assertThat(newUser.getUid(), greaterThanOrEqualTo(0));
+        assertThat(newUser.getSeen(), is(nullValue()));
+        messagesService.createMessage(newUser.getUid(), "YO", "", null);
+        assertThat(userService.getUserByUID(newUser.getUid()).get().getSeen(), greaterThanOrEqualTo(now));
     }
     @Test
     public void signupTest() throws Exception {