/*
* Copyright (C) 2008-2017, Juick
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License as
* published by the Free Software Foundation, either version 3 of the
* License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see .
*/
package com.juick.server.tests;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.juick.ExternalToken;
import com.juick.Message;
import com.juick.Tag;
import com.juick.User;
import com.juick.server.CommandsManager;
import com.juick.server.EmailManager;
import com.juick.server.XMPPConnection;
import com.juick.server.XMPPServer;
import com.juick.server.helpers.AnonymousUser;
import com.juick.server.helpers.CommandResult;
import com.juick.server.helpers.TagStats;
import com.juick.server.util.HttpUtils;
import com.juick.service.*;
import com.juick.util.DateFormattersHolder;
import com.juick.util.MessageUtils;
import org.apache.commons.lang3.StringUtils;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration;
import org.springframework.boot.builder.SpringApplicationBuilder;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.http.MediaType;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.TestPropertySource;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.MvcResult;
import org.springframework.util.FileSystemUtils;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.util.UriComponents;
import org.springframework.web.util.UriComponentsBuilder;
import rocks.xmpp.addr.Jid;
import rocks.xmpp.core.stanza.model.Stanza;
import rocks.xmpp.core.stanza.model.StanzaError;
import rocks.xmpp.core.stanza.model.client.ClientMessage;
import rocks.xmpp.core.stanza.model.errors.Condition;
import rocks.xmpp.core.stanza.model.server.ServerMessage;
import javax.inject.Inject;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.net.URI;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.sql.Timestamp;
import java.time.Instant;
import java.util.*;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.stream.IntStream;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
import static org.junit.Assert.*;
import static org.springframework.security.test.web.servlet.request.SecurityMockMvcRequestPostProcessors.httpBasic;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.*;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.*;
/**
* Created by vitalyster on 25.11.2016.
*/
@RunWith(SpringRunner.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
@TestPropertySource(properties = {"broken_ssl_hosts=localhost,serverstorageisfull.tld"})
@AutoConfigureMockMvc
public class ServerTests {
@Inject
private MockMvc mockMvc;
@Inject
private MessagesService messagesService;
@Inject
private UserService userService;
@Inject
private TagService tagService;
@Inject
private ObjectMapper jsonMapper;
@Inject
private WebApplicationContext wac;
@Inject
private XMPPServer server;
@Inject
private CommandsManager commandsManager;
@Inject
private XMPPConnection router;
@Inject
private SubscriptionService subscriptionService;
@Inject
private PrivacyQueriesService privacyQueriesService;
@Inject
private JdbcTemplate jdbcTemplate;
@Inject
private EmailService emailService;
@Inject
private PMQueriesService pmQueriesService;
@Inject
private TelegramService telegramService;
@Inject
private CrosspostService crosspostService;
@Inject
private ImagesService imagesService;
@Value("${hostname:localhost}")
private Jid jid;
@Value("${xmppbot_jid:juick@localhost}")
private Jid botJid;
@Value("${upload_tmp_dir:#{systemEnvironment['TEMP'] ?: '/tmp'}}")
private String tmpDir;
@Value("${img_path:#{systemEnvironment['TEMP'] ?: '/tmp'}}")
private String imgDir;
private static User ugnich, freefd, juick;
static String ugnichName, ugnichPassword, freefdName, freefdPassword, juickName, juickPassword;
static Message msg;
static int juickTagId;
private static boolean isSetUp = false;
@Before
public void setUp() throws IOException {
Files.createDirectory(Paths.get(imgDir, "p"));
Files.createDirectory(Paths.get(imgDir, "photos-1024"));
Files.createDirectory(Paths.get(imgDir, "photos-512"));
Files.createDirectory(Paths.get(imgDir, "ps"));
if (!isSetUp) {
ugnichName = "ugnich";
ugnichPassword = "secret";
freefdName = "freefd";
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);
String msgText = "Привет, я - Угнич";
int mid = messagesService.createMessage(ugnich.getUid(), msgText, "png", null);
msg = messagesService.getMessage(mid);
tagService.createTag("тест");
juickTagId = tagService.createTag("juick");
isSetUp = true;
}
}
@After
public void teardown() throws IOException {
FileSystemUtils.deleteRecursively(Paths.get(imgDir, "p"));
FileSystemUtils.deleteRecursively(Paths.get(imgDir, "photos-1024"));
FileSystemUtils.deleteRecursively(Paths.get(imgDir, "photos-512"));
FileSystemUtils.deleteRecursively(Paths.get(imgDir, "ps"));
}
@Test
public void getMyFeed() {
int mid0 = messagesService.createMessage(ugnich.getUid(), "test", null, null);
int mid2 = messagesService.createMessage(ugnich.getUid(), "test2", null, null);
subscriptionService.subscribeUser(userService.getUserByUID(freefd.getUid()).orElse(AnonymousUser.INSTANCE),
userService.getUserByUID(ugnich.getUid()).orElse(AnonymousUser.INSTANCE));
List 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);
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));
assertThat(messagesService.getMyFeed(freefd.getUid(), mid2, true).get(0), equalTo(mid0));
assertThat(messagesService.recommendMessage(mid0, ugnich.getUid()), equalTo(MessagesService.RecommendStatus.Added));
assertThat(messagesService.getMessage(mid0).getLikes(), equalTo(1));
assertThat(messagesService.recommendMessage(mid0, ugnich.getUid()), equalTo(MessagesService.RecommendStatus.Deleted));
assertThat(messagesService.getMessage(mid0).getLikes(), equalTo(0));
assertThat(messagesService.getAll(ugnich.getUid(), 0).get(0), equalTo(mid3));
Tag yoTag = tagService.getTag("yoyo", true);
assertThat(tagService.getTag("YOYO", false), equalTo(yoTag));
int mid = messagesService.createMessage(ugnich.getUid(), "yo", null, Collections.singletonList(yoTag));
List subscribers = subscriptionService.getSubscribedUsers(ugnich.getUid(), mid);
telegramService.createTelegramUser(12345, "freefd");
String loginhash = jdbcTemplate.queryForObject("SELECT loginhash FROM telegram where tg_id=?",
String.class, 12345);
crosspostService.setTelegramUser(loginhash, freefd.getUid());
List telegramSubscribers = telegramService.getTelegramIdentifiers(subscribers);
assertThat(subscribers.size(), equalTo(1));
assertThat(subscribers.size(), equalTo(telegramSubscribers.size()));
assertThat(subscribers.get(0).getUid(), equalTo(freefd.getUid()));
tagService.blacklistTag(freefd, yoTag);
List subscribers2 = subscriptionService.getSubscribedUsers(ugnich.getUid(), mid);
assertThat(subscribers2.size(), equalTo(0));
assertThat(telegramService.getTelegramIdentifiers(subscribers2).size(), equalTo(0));
tagService.blacklistTag(freefd, yoTag);
assertThat(subscriptionService.getSubscribedUsers(ugnich.getUid(), mid).size(), equalTo(1));
}
@Test
public void pmTests() {
pmQueriesService.createPM(freefd.getUid(), ugnich.getUid(), "hello");
Message pm = pmQueriesService.getPMMessages(ugnich.getUid(), freefd.getUid()).get(0);
assertThat(pm.getText(), equalTo("hello"));
assertThat(pm.getUser().getUid(), equalTo(freefd.getUid()));
}
@Test
public void messageTests() {
int user_id = userService.createUser("mmmme", "secret");
User user = userService.getUserByUID(user_id).orElse(new User());
assertEquals("it should be me", "mmmme", user.getName());
int mid = messagesService.createMessage(user_id, "yo", null, new ArrayList<>());
Message msg = messagesService.getMessage(mid);
assertEquals("yo", msg.getText());
User me = msg.getUser();
assertEquals("mmmme", me.getName());
assertEquals("mmmme", messagesService.getMessageAuthor(mid).getName());
int tagID = tagService.createTag("weather");
Tag tag = tagService.getTag(tagID);
List tagList = new ArrayList<>();
tagList.add(tag);
int mid2 = messagesService.createMessage(user_id, "yo2", null, tagList);
Message msg2 = messagesService.getMessage(mid2);
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(new User());
int rid = messagesService.createReply(msg2.getMid(), 0, ugnich.getUid(), "bla-bla", null);
assertEquals(1, rid);
assertThat(msg2.getTo(), equalTo(null));
Message reply = messagesService.getReply(msg2.getMid(), rid);
assertThat(reply.getTo().getName(), equalTo(user.getName()));
List replies = messagesService.getReplies(msg2.getMid());
assertThat(replies.size(), equalTo(1));
assertThat(replies.get(0), equalTo(reply));
int ridToReply = messagesService.createReply(msg2.getMid(), 1, ugnich_id, "blax2", null);
Message reply2 = messagesService.getReply(msg2.getMid(), ridToReply);
assertThat(reply.getTo().getName(), equalTo(user.getName()));
List replies2 = messagesService.getReplies(msg2.getMid());
assertThat(replies2.size(), equalTo(2));
assertThat(replies2.get(1), equalTo(reply2));
Message msg3 = messagesService.getMessage(mid2);
assertEquals(2, msg3.getReplies());
assertEquals("weather", msg3.getTags().get(0).getName());
assertEquals(ugnich.getUid(), userService.checkPassword(ugnich.getName(), "x"));
assertEquals(-1, userService.checkPassword(ugnich.getName(), "xy"));
subscriptionService.subscribeMessage(msg.getMid(), user.getUid());
subscriptionService.subscribeMessage(msg.getMid(), ugnich.getUid());
int reply_id = messagesService.createReply(msg.getMid(), 0, ugnich_id, "comment", null);
assertEquals(1, subscriptionService.getUsersSubscribedToComments(msg,
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);
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);
Message msg4 = messagesService.getMessage(mid4);
assertEquals("tags string should be empty", StringUtils.EMPTY, MessageUtils.getTagsString(msg4));
messagesService.deleteMessage(user_id, mid4);
}
@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));
}
@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));
}
@Test
public void messageUpdatedTimeShouldMatchLastReplyTime() throws InterruptedException {
int ugnich_id = userService.createUser("hugnich4", "x");
int mid = messagesService.createMessage(ugnich_id, "yo", null, null);
Instant ts = jdbcTemplate.queryForObject("SELECT updated FROM messages WHERE message_id=?",
Timestamp.class, mid).toInstant();
Thread.sleep(1000);
int rid = messagesService.createReply(mid, 0, ugnich_id, "people", null);
Instant rts = jdbcTemplate.queryForObject("SELECT updated FROM messages WHERE message_id=?",
Timestamp.class, mid).toInstant();
assertThat(rts, greaterThan(ts));
Message msg = messagesService.getReply(mid, rid);
assertThat(rts, equalTo(msg.getTimestamp()));
messagesService.deleteMessage(ugnich_id, mid);
}
@Test
public void testAllUnAuthorized() throws Exception {
mockMvc.perform(get("/"))
.andExpect(status().isMovedPermanently());
mockMvc.perform(get("/auth"))
.andExpect(status().isUnauthorized());
mockMvc.perform(get("/home"))
.andExpect(status().isUnauthorized());
mockMvc.perform(get("/messages/recommended"))
.andExpect(status().isUnauthorized());
mockMvc.perform(get("/messages/set_privacy"))
.andExpect(status().isUnauthorized());
}
@Test
public void homeTestWithMessages() throws Exception {
mockMvc.perform(
get("/home")
.with(httpBasic(ugnichName, ugnichPassword)))
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8))
.andExpect(jsonPath("$[-1].mid", is(msg.getMid())))
.andExpect(jsonPath("$[-1].timestamp",
is(DateFormattersHolder.getMessageFormatterInstance().format(msg.getTimestamp()))))
.andExpect(jsonPath("$[-1].body", is(msg.getText())))
.andExpect(jsonPath("$[-1].attachment.url", is("https://i.juick.com/p/1.png")))
.andExpect(jsonPath("$[-1].attachment.small.url", is("https://i.juick.com/photos-512/1.png")));
}
@Test
public void homeTestWithMessagesAndRememberMe() throws Exception {
String ugnichHash = userService.getHashByUID(ugnich.getUid());
mockMvc.perform(
get("/home")
.with(httpBasic(ugnichName, ugnichPassword)))
.andExpect(status().isOk())
.andReturn();
mockMvc.perform(get("/home")
.param("hash", ugnichHash))
.andExpect(status().isOk());
}
@Test
public void homeTestWithMessagesAndSimpleCors() throws Exception {
mockMvc.perform(
get("/home")
.with(httpBasic(ugnichName, ugnichPassword))
.header("Origin", "http://api.example.net"))
.andExpect(status().isOk())
.andExpect(header().string("Access-Control-Allow-Origin", "*"));
}
@Test
public void homeTestWithPreflightCors() throws Exception {
mockMvc.perform(
options("/home")
.with(httpBasic(ugnichName, ugnichPassword))
.header("Origin", "http://api.example.net")
.header("Access-Control-Request-Method", "POST")
.header("Access-Control-Request-Headers", "X-PINGOTHER, Content-Type"))
.andExpect(status().isOk())
.andExpect(header().string("Access-Control-Allow-Origin", "*"))
.andExpect(header().string("Access-Control-Allow-Methods", "POST,GET,PUT,OPTIONS,DELETE"))
.andExpect(header().string("Access-Control-Allow-Headers", "X-PINGOTHER, Content-Type"));
}
@Test
public void anonymousApis() throws Exception {
mockMvc.perform(get("/messages"))
.andExpect(status().isOk());
mockMvc.perform(get("/users")
.param("uname", "ugnich")
.param("uname", "freefd"))
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8))
.andExpect(jsonPath("$", hasSize(2)));
}
@Test
public void tags() throws Exception {
Tag weather = tagService.getTag("weather", true);
Tag yo = tagService.getTag("yo", true);
messagesService.createMessage(ugnich.getUid(), "text", null, Arrays.asList(yo, weather));
messagesService.createMessage(freefd.getUid(), "text2", null, Collections.singletonList(yo));
MvcResult result = mockMvc.perform(get("/tags"))
.andExpect(status().isOk())
.andReturn();
List tagsFromApi = jsonMapper.readValue(result.getResponse().getContentAsString(),
new TypeReference>(){});
TagStats yoStats = tagsFromApi.stream().filter(t -> t.getTag().getName().equals("yo")).findFirst().get();
assertThat(yoStats.getUsageCount(), is(2));
MvcResult result2 = mockMvc.perform(get("/tags")
.param("user_id", String.valueOf(ugnich.getUid())))
.andExpect(status().isOk())
.andReturn();
List ugnichTagsFromApi = jsonMapper.readValue(result2.getResponse().getContentAsString(),
new TypeReference>(){});
TagStats yoUgnichStats = ugnichTagsFromApi.stream().filter(t -> t.getTag().getName().equals("yo")).findFirst().get();
assertThat(yoUgnichStats.getUsageCount(), is(1));
}
@Test
public void postWithReferer() throws Exception {
mockMvc.perform(post("/post")
.param("body", "yo")
.with(httpBasic(ugnichName, ugnichPassword)))
.andExpect(status().isOk());
}
@Test
public void threadWithEphemeralNumberShouldReturn404() throws Exception {
mockMvc.perform(get("/thread").param("mid", "999999999")
.with(httpBasic(ugnichName, ugnichPassword))).andExpect(status().is4xxClientError());
}
@Test
public void performRequestsWithIssuedToken() throws Exception {
String ugnichHash = userService.getHashByUID(ugnich.getUid());
mockMvc.perform(get("/home")).andExpect(status().isUnauthorized());
mockMvc.perform(get("/auth"))
.andExpect(status().isUnauthorized());
mockMvc.perform(get("/auth").with(httpBasic(ugnichName, "wrongpassword")))
.andExpect(status().isUnauthorized());
MvcResult result = mockMvc.perform(get("/auth").with(httpBasic(ugnichName, ugnichPassword)))
.andExpect(status().isOk())
.andReturn();
String authHash = result.getResponse().getContentAsString();
assertThat(authHash, equalTo(ugnichHash));
mockMvc.perform(get("/home").param("hash", ugnichHash)).andExpect(status().isOk());
}
@Test
public void registerForNotificationsTests() throws Exception {
String token = "123456";
ExternalToken registration = new ExternalToken(null, "apns", token, null);
mockMvc.perform(put("/notifications").with(httpBasic(ugnichName, ugnichPassword))
.contentType(MediaType.APPLICATION_JSON_UTF8)
.content(jsonMapper.writeValueAsBytes(Collections.singletonList(registration))))
.andExpect(status().isOk());
MvcResult result = mockMvc.perform(get("/notifications")
.param("uid", String.valueOf(ugnich.getUid()))
.with(httpBasic(juickName, juickPassword)))
.andExpect(status().isOk())
.andReturn();
List user = jsonMapper.readValue(result.getResponse().getContentAsString(),
new TypeReference>() {
});
assertThat(user.get(0).getTokens().get(0).getToken(), equalTo(token));
}
@Test
public void tg2juickLinks() {
UriComponents uriComponents = UriComponentsBuilder.fromUriString("http://juick.com/123456#23").build();
assertThat(uriComponents.getPath().substring(1), is("123456"));
assertThat(uriComponents.getFragment(), is("23"));
}
@Test
public void notificationsTokensTest() throws Exception {
List tokens = Collections.singletonList(new ExternalToken(null, "gcm", "123456", null));
mockMvc.perform(delete("/notifications").with(httpBasic(ugnichName, ugnichPassword))
.contentType(MediaType.APPLICATION_JSON_UTF8)
.content(jsonMapper.writeValueAsBytes(tokens))).andExpect(status().isForbidden());
mockMvc.perform(delete("/notifications").with(httpBasic(juickName, juickPassword))
.contentType(MediaType.APPLICATION_JSON_UTF8)
.content(jsonMapper.writeValueAsBytes(tokens))).andExpect(status().isOk());
}
@Test
public void notificationsSettingsAllowedOnlyForServiceUser() throws Exception {
mockMvc.perform(get("/notifications").with(httpBasic(juickName, juickPassword))
.param("mid", "1").param("uid", String.valueOf(ugnich.getUid()))).andExpect(status().isOk());
mockMvc.perform(get("/notifications")
.param("mid", "1").param("uid", String.valueOf(ugnich.getUid()))).andExpect(status().isUnauthorized());
}
@Test
public void topTest() {
int topmid = messagesService.createMessage(ugnich.getUid(), "top message", null, null);
IntStream.rangeClosed(6, 12).forEach(i -> {
messagesService.createReply(topmid, 0, i, "yo", null);
});
assertThat(messagesService.getPopularCandidates().get(0), is(topmid));
Tag juickTag = tagService.getTag(juickTagId);
assertThat(juickTag.TID, is(2));
tagService.updateTags(topmid, Collections.singletonList(juickTag));
assertThat(messagesService.getPopularCandidates().isEmpty(), is(true));
}
@Test
public void inReplyToScannerTest() {
String header = "<123456.56@juick.com>";
Scanner headerScanner = new Scanner(header).useDelimiter(EmailManager.MSGID_PATTERN);
int mid = Integer.parseInt(headerScanner.next());
int rid = Integer.parseInt(headerScanner.next());
assertThat(mid, equalTo(123456));
assertThat(rid, equalTo(56));
}
@Test
public void lastMessagesTest() throws Exception {
mockMvc.perform(
get("/rss/"))
.andExpect(status().isOk())
.andExpect(content().contentType("application/rss+xml;charset=UTF-8"))
.andExpect(xpath("/rss/channel/description").string("The latest messages at Juick"));
}
@Test
public void statusPageIsUp() throws Exception {
mockMvc.perform(get("/api/status").with(httpBasic(ugnichName, ugnichPassword))).andExpect(status().isOk());
assertThat(server.getJid(), equalTo(jid));
}
@Test
public void botIsUpAndProcessingResourceConstraints() throws Exception {
int renhaId = userService.createUser("renha", "umnnbt");
Jid from = Jid.of("renha@serverstorageisfull.tld");
jdbcTemplate.update("INSERT INTO jids(user_id,jid,active) VALUES(?,?,?)",
renhaId, from.toEscapedString(), 1);
rocks.xmpp.core.stanza.model.Message xmppMessage = new rocks.xmpp.core.stanza.model.Message();
xmppMessage.setType(rocks.xmpp.core.stanza.model.Message.Type.ERROR);
xmppMessage.setFrom(from);
xmppMessage.setTo(botJid);
StanzaError err = new StanzaError(StanzaError.Type.CANCEL, Condition.RESOURCE_CONSTRAINT);
xmppMessage.setError(err);
Function isActive = f -> jdbcTemplate.queryForObject("SELECT active FROM jids WHERE user_id=?", Integer.class, f) == 1;
assertThat(isActive.apply(renhaId), equalTo(true));
ClientMessage result = router.incomingMessage(xmppMessage);
assertNull(result);
assertThat(isActive.apply(renhaId), equalTo(false));
xmppMessage.setError(null);
xmppMessage.setType(rocks.xmpp.core.stanza.model.Message.Type.CHAT);
xmppMessage.setBody("On");
result = router.incomingMessage(xmppMessage);
assertThat(result.getBody(), equalTo("XMPP notifications are activated"));
assertTrue(isActive.apply(renhaId));
xmppMessage.setBody("*test test");
result = router.incomingMessage(xmppMessage);
assertThat(result.getBody(), startsWith("New message posted"));
xmppMessage.setFrom(Jid.of(String.valueOf(renhaId), "uid.juick.com", "perl"));
xmppMessage.setBody("PING");
result = router.incomingMessage(xmppMessage);
assertThat(result.getBody(), equalTo("PONG"));
int secretlySadId = userService.createUser("secretlysad", "bbk");
xmppMessage.setTo(botJid.withLocal("secretlysad"));
xmppMessage.setBody("What's up?");
result = router.incomingMessage(xmppMessage);
assertThat(result.getBody(), startsWith("Private message sent"));
xmppMessage.setFrom(botJid);
xmppMessage.setTo(botJid.withLocal("pm"));
Message pm = new Message();
pm.setUser(userService.getUserByJID(from.toEscapedString()));
pm.setTo(userService.getUserByUID(secretlySadId).orElseThrow(IllegalAccessError::new));
xmppMessage.addExtension(pm);
result = router.incomingMessage(xmppMessage);
// TODO: assert events
}
@Test
public void botCommandsTests() throws Exception {
URI emptyUri = URI.create(StringUtils.EMPTY);
assertThat(commandsManager.processCommand(new User(), "PING", emptyUri).getText(), is("PONG"));
// subscription commands have two lines, others have 1
assertThat(commandsManager.processCommand(new User(), "help", emptyUri).getText().split("\n").length, is(32));
}
@Test
public void protocolTests() throws Exception {
URI emptyUri = URI.create(StringUtils.EMPTY);
int uid = userService.createUser("me", "secret");
User user = userService.getUserByUID(uid).orElse(new User());
Tag yo = tagService.getTag("yo", true);
Message msg = commandsManager.processCommand(user, "*yo yoyo", URI.create("http://static.juick.com/settings/facebook.png")).getNewMessage().get();
assertThat(msg.getAttachmentType(), is("png"));
Message msgreply = commandsManager.processCommand(user, "#" + msg.getMid() + " yyy", HttpUtils.downloadImage(URI.create("http://static.juick.com/settings/xmpp.png").toURL(), tmpDir)).getNewMessage().get();
assertThat(msgreply.getAttachmentType(), equalTo("png"));
assertEquals("text should match", "yoyo",
messagesService.getMessage(msg.getMid()).getText());
assertEquals("tag should match", "yo",
tagService.getMessageTags(msg.getMid()).get(0).getTag().getName());
CommandResult yoyoMsg = commandsManager.processCommand(user, "*yo", URI.create("http://static.juick.com/settings/facebook.png"));
assertTrue(yoyoMsg.getNewMessage().isPresent());
assertThat(yoyoMsg.getNewMessage().get().getTags().get(0), is(yo));
int mid = yoyoMsg.getNewMessage().get().getMid();
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(new User());
assertEquals("should be subscribed", "Subscribed",
commandsManager.processCommand(readerUser, "S #" + mid, emptyUri).getText());
assertEquals("should be favorited", "Message is added to your recommendations",
commandsManager.processCommand(readerUser, "! #" + mid, emptyUri).getText());
int rid = messagesService.createReply(mid, 0, uid, "comment", null);
assertEquals("number of subscribed users should match", 1,
subscriptionService.getUsersSubscribedToComments(
messagesService.getMessage(mid),
messagesService.getReply(mid, rid)).size());
privacyQueriesService.blacklistUser(user, readerUser);
assertEquals("number of subscribed users should match", 0,
subscriptionService.getUsersSubscribedToComments(
messagesService.getMessage(mid),
messagesService.getReply(mid, rid)).size());
assertEquals("should be subscribed", "Subscribed to @" + user.getName(),
commandsManager.processCommand(readerUser, "S @" + user.getName(), emptyUri)
.getText());
List friends = userService.getUserFriends(readerUid);
assertEquals("number of friend users should match", 2,
friends.size());
assertEquals("number of reader users should match", 1,
userService.getUserReaders(uid).size());
String expectedSecondReply = "Reply posted.\n#" + mid + "/2 "
+ "https://juick.com/" + mid + "#2";
String expectedThirdReply = "Reply posted.\n#" + mid + "/3 "
+ "https://juick.com/" + mid + "#3";
assertEquals("should be second reply", expectedSecondReply,
commandsManager.processCommand(user, "#" + mid + " yoyo", URI.create("http://static.juick.com/settings/facebook.png")).getText());
assertEquals("should be third reply", expectedThirdReply,
commandsManager.processCommand(user, "#" + mid + "/2 ",
URI.create("http://static.juick.com/settings/facebook.png")).getText());
Message reply = messagesService.getReplies(mid).stream().filter(m -> m.getRid() == 3).findFirst()
.orElse(new Message());
assertEquals("should be reply to second comment", 2, reply.getReplyto());
assertEquals("tags should NOT be updated", "It is not your message",
commandsManager.processCommand(readerUser, "#" + mid + " *yo *there", emptyUri)
.getText());
assertEquals("tags should be updated", "Tags are updated",
commandsManager.processCommand(user, "#" + mid + " *there", emptyUri).getText());
assertEquals("number of tags should match", 2,
tagService.getMessageTags(mid).size());
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, mid).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(new User());
assertEquals("should be subscribed", "Subscribed",
commandsManager.processCommand(taggerUser, "S *yo", emptyUri).getText());
assertEquals("number of subscribed users should match", 2,
subscriptionService.getSubscribedUsers(uid, mid).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, mid).size());
assertEquals("number of readers should match", 1,
userService.getUserReaders(uid).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());
assertEquals("number of friends should match", 1,
userService.getUserFriends(uid).size());
assertEquals("should be unsubscribed", "Unsubscribed from #" + mid,
commandsManager.processCommand(readerUser, "u #" + mid, emptyUri).getText());
assertEquals("number of subscribed users should match", 0,
subscriptionService.getUsersSubscribedToComments(messagesService.getMessage(mid),
messagesService.getReply(mid, rid)).size());
assertNotEquals("should NOT be deleted", String.format("Message %s deleted", mid),
commandsManager.processCommand(readerUser, "D #" + mid, emptyUri).getText());
assertEquals("should be deleted", "Message deleted",
commandsManager.processCommand(user, "D #" + mid, emptyUri).getText());
assertEquals("should be not found", "Message not found",
commandsManager.processCommand(user, "#" + mid, emptyUri).getText());
}
@Test
public void mailParserTest() throws Exception {
String mail = "MIME-Version: 1.0\n" +
"Received: by 10.176.0.242 with HTTP; Fri, 16 Mar 2018 05:31:50 -0700 (PDT)\n" +
"In-Reply-To: <2891710.100@juick.com>\n" +
"References: <2891710.0@juick.com> <2891710.100@juick.com>\n" +
"Date: Fri, 16 Mar 2018 15:31:50 +0300\n" +
"Delivered-To: vitalyster@gmail.com\n" +
"Message-ID: \n" +
"Subject: Re: New reply to TJ\n" +
"From: Vitaly Takmazov \n" +
"To: Juick \n" +
"Content-Type: multipart/alternative; boundary=\"001a11454886e42be5056786ca70\"\n" +
"\n" +
"--001a11454886e42be5056786ca70\n" +
"Content-Type: text/plain; charset=\"UTF-8\"\n" +
"\n" +
"s2313334\n" +
"\n" +
"--001a11454886e42be5056786ca70\n" +
"Content-Type: text/html; charset=\"UTF-8\"\n" +
"\n" +
"s2313334
\n" +
"\n" +
"--001a11454886e42be5056786ca70--";
mockMvc.perform(post("/mail").with(httpBasic(juickName, juickPassword)).content(mail))
.andExpect(status().isOk());
}
@Test
public void websocketsTest() throws Exception {
ConfigurableApplicationContext context = new SpringApplicationBuilder(
WebsocketClientConfig.class, PropertyPlaceholderAutoConfiguration.class)
.run("--spring.main.web_environment=false");
long count = context.getBean(WebsocketClientConfig.class).getLatch().getCount();
context.close();
Assert.assertThat(count, equalTo(0L));
mockMvc.perform(get("/ws/_all")).andExpect(status().isBadRequest());
}
@Test
public void likesTests() throws Exception {
int mid = messagesService.createMessage(ugnich.getUid(), "to be liked", null, null);
String freefdHash = userService.getHashByUID(freefd.getUid());
int freefdMid = messagesService.createMessage(freefd.getUid(), "to be not liked", null, null);
mockMvc.perform(post("/like?mid=" + mid + "&hash=" + freefdHash))
.andExpect(status().isOk())
.andExpect(jsonPath("$.status", is("Message is added to your recommendations")));
mockMvc.perform(post("/like?mid=" + freefdMid + "&hash=" + freefdHash))
.andExpect(status().isForbidden());
}
}