/*
* 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.annotation.JsonInclude;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.gargoylesoftware.htmlunit.CookieManager;
import com.gargoylesoftware.htmlunit.WebClient;
import com.gargoylesoftware.htmlunit.css.StyleElement;
import com.gargoylesoftware.htmlunit.html.DomElement;
import com.gargoylesoftware.htmlunit.html.HtmlPage;
import com.jayway.jsonpath.JsonPath;
import com.juick.*;
import com.juick.server.*;
import com.juick.server.api.activity.model.ActivityObject;
import com.juick.service.component.MessageEvent;
import com.juick.model.AnonymousUser;
import com.juick.model.CommandResult;
import com.juick.model.TagStats;
import com.juick.server.util.HttpUtils;
import com.juick.server.util.ImageUtils;
import com.juick.server.www.Utils;
import com.juick.server.xmpp.helpers.XMPPStatus;
import com.juick.server.xmpp.s2s.ConnectionIn;
import com.juick.service.*;
import com.juick.util.DateFormattersHolder;
import com.juick.util.MessageUtils;
import com.mitchellbosecke.pebble.PebbleEngine;
import com.mitchellbosecke.pebble.error.PebbleException;
import com.mitchellbosecke.pebble.template.PebbleTemplate;
import org.apache.commons.codec.CharEncoding;
import org.apache.commons.collections4.CollectionUtils;
import org.apache.commons.collections4.IteratorUtils;
import org.apache.commons.io.IOUtils;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.text.StringEscapeUtils;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
import org.junit.rules.ExpectedException;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.boot.test.web.client.TestRestTemplate;
import org.springframework.core.io.ClassPathResource;
import org.springframework.http.*;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.mock.web.MockMultipartFile;
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.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.context.WebApplicationContext;
import org.springframework.web.util.UriComponents;
import org.springframework.web.util.UriComponentsBuilder;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.xml.sax.SAXException;
import rocks.xmpp.addr.Jid;
import rocks.xmpp.core.session.Extension;
import rocks.xmpp.core.session.XmppSession;
import rocks.xmpp.core.session.XmppSessionConfiguration;
import rocks.xmpp.core.stanza.model.StanzaError;
import rocks.xmpp.core.stanza.model.client.ClientMessage;
import rocks.xmpp.core.stanza.model.errors.Condition;
import javax.inject.Inject;
import javax.servlet.http.Cookie;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import java.io.*;
import java.net.Socket;
import java.net.URI;
import java.net.URISyntaxException;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
import java.sql.Timestamp;
import java.time.Instant;
import java.util.*;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import java.util.stream.StreamSupport;
import static junit.framework.TestCase.assertTrue;
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.MockMvcResultHandlers.print;
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",
"ios_app_id=12345678.com.juick.ExampleApp",
"xmppbot_jid=juick@localhost/Juick",
"hostname=localhost",
"componentname=localhost"
})
@AutoConfigureMockMvc
public class ServerTests {
@Inject
private MockMvc mockMvc;
@Inject
private WebClient webClient;
@Inject
private TestRestTemplate restTemplate;
@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;
@Inject
private ServerManager serverManager;
@Inject
private KeystoreManager keystoreManager;
@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;
@Inject
private PebbleEngine pebbleEngine;
@Value("${ios_app_id:}")
private String appId;
private static User ugnich, freefd, juick;
static String ugnichName, ugnichPassword, freefdName, freefdPassword, juickName, juickPassword;
URI emptyUri = URI.create(StringUtils.EMPTY);
private static boolean isSetUp = false;
@Before
public void setUp() throws Exception {
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);
subscriptionService.subscribeUser(freefd, ugnich);
webClient.getOptions().setJavaScriptEnabled(false);
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);
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));
Message msg = messagesService.getMessage(mid);
List subscribers = subscriptionService.getSubscribedUsers(ugnich.getUid(), msg);
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(), msg);
assertThat(subscribers2.size(), equalTo(0));
assertThat(telegramService.getTelegramIdentifiers(subscribers2).size(), equalTo(0));
tagService.blacklistTag(freefd, yoTag);
assertThat(subscriptionService.getSubscribedUsers(ugnich.getUid(), msg).size(), equalTo(1));
subscriptionService.unSubscribeUser(freefd, ugnich);
assertThat(subscriptionService.getSubscribedUsers(ugnich.getUid(), msg).size(), equalTo(0));
Message mentionMessage = new Message();
mentionMessage.setText("@freefd - dick");
assertThat(subscriptionService.getSubscribedUsers(ugnich.getUid(), mentionMessage).size(), equalTo(1));
subscriptionService.subscribeUser(freefd, ugnich);
assertThat(subscriptionService.getSubscribedUsers(ugnich.getUid(), mentionMessage).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(AnonymousUser.INSTANCE);
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(AnonymousUser.INSTANCE);
int rid = messagesService.createReply(msg2.getMid(), 0, ugnich, "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(user, msg2.getMid());
assertThat(replies.size(), equalTo(1));
assertThat(replies.get(0), equalTo(reply));
int ridToReply = messagesService.createReply(msg2.getMid(), 1, ugnich, "blax2", null);
Message reply2 = messagesService.getReply(msg2.getMid(), ridToReply);
assertThat(reply.getTo().getName(), equalTo(user.getName()));
List replies2 = messagesService.getReplies(user, 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, user);
subscriptionService.subscribeMessage(msg, ugnich);
int reply_id = messagesService.createReply(msg.getMid(), 0, ugnich, "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);
}
public ExpectedException exception = ExpectedException.none();
@Test
public void likeTypeStatsTests(){
int user_id = userService.createUser("dsdss", "secret");
final int freefdId = freefd.getUid();
int mid = messagesService.createMessage(user_id, "yo", null, new ArrayList<>());
messagesService.likeMessage(mid, freefdId , 2);
messagesService.likeMessage(mid, freefdId,2);
messagesService.likeMessage(mid, freefdId,3);
messagesService.likeMessage(mid, freefdId,1);
Message msg4 = messagesService.getMessage(mid);
assertThat(msg4.getLikes(), equalTo(1));
Assert.assertEquals(2, msg4.getReactions().stream().filter(r -> r.getId() == 2)
.findFirst().orElseThrow(IllegalStateException::new).getCount());
Assert.assertEquals(1,msg4.getReactions().stream().filter(r -> r.getId() == 3)
.findFirst().orElseThrow(IllegalStateException::new).getCount());
}
@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, "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("/api/"))
.andExpect(status().isMovedPermanently());
mockMvc.perform(get("/api/auth"))
.andExpect(status().isUnauthorized());
mockMvc.perform(get("/api/home"))
.andExpect(status().isUnauthorized());
mockMvc.perform(get("/api/messages/recommended"))
.andExpect(status().isUnauthorized());
mockMvc.perform(get("/api/messages/set_privacy"))
.andExpect(status().isUnauthorized());
}
@Test
public void homeTestWithMessages() throws Exception {
String msgText = "Привет, я - Угнич";
CommandResult result = commandsManager.processCommand(ugnich, msgText, URI.create("http://static.juick.com/settings/facebook.png"));
int mid = result.getNewMessage().get().getMid();
Message msg = messagesService.getMessage(mid);
tagService.createTag("тест");
mockMvc.perform(
get("/api/home")
.with(httpBasic(ugnichName, ugnichPassword)))
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8))
.andExpect(jsonPath("$[0].mid", is(msg.getMid())))
.andExpect(jsonPath("$[0].timestamp",
is(DateFormattersHolder.getMessageFormatterInstance().format(msg.getTimestamp()))))
.andExpect(jsonPath("$[0].body", is(msg.getText())))
.andExpect(jsonPath("$[0].attachment.url",
is(String.format("https://i.juick.com/p/%d.png", msg.getMid()))))
.andExpect(jsonPath("$[0].attachment.small.url",
is(String.format("https://i.juick.com/photos-512/%d.png", msg.getMid()))))
.andExpect(jsonPath("$[0].user.avatar").doesNotExist());
}
@Test
public void homeTestWithMessagesAndRememberMe() throws Exception {
String ugnichHash = userService.getHashByUID(ugnich.getUid());
mockMvc.perform(
get("/api/home")
.with(httpBasic(ugnichName, ugnichPassword)))
.andExpect(status().isOk())
.andReturn();
mockMvc.perform(get("/api/home")
.param("hash", ugnichHash))
.andExpect(status().isOk());
}
@Test
public void homeTestWithMessagesAndSimpleCors() throws Exception {
mockMvc.perform(
get("/api/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("/api/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("/api/messages"))
.andExpect(status().isOk());
mockMvc.perform(get("/api/users")
.param("uname", "ugnich")
.param("uname", "freefd"))
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8))
.andExpect(jsonPath("$", hasSize(2)));
}
@Test
public void messagesUrlTest() throws Exception {
int user_id = userService.createUser("dsds4345", "secret");
String freefdHash = userService.getHashByUID(freefd.getUid());
System.out.println("user_id"+ user_id);
String userIdHash = userService.getHashByUID(user_id);
final int freefdId = freefd.getUid();
int mid = messagesService.createMessage(user_id, "yo", null, new ArrayList<>());
messagesService.likeMessage(mid, freefdId, 2 );
messagesService.likeMessage(mid, freefdId, 2 );
messagesService.likeMessage(mid, freefdId, 3 );
mockMvc.perform(get("/api/messages?"+ "hash=" + userIdHash))
.andDo(print())
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8))
.andExpect((jsonPath("$[0].reactions[?(@.id == 3)].count",
is(Collections.singletonList(1)))))
.andExpect((jsonPath("$[0].reactions[?(@.id == 2)].count",
is(Collections.singletonList(2)))));
mockMvc.perform(get("/api/reactions?hash=" + userIdHash))
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8))
.andExpect(jsonPath("$.length()", is(7)));
}
@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("/api/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("/api/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("/api/post")
.param("body", "yo")
.with(httpBasic(ugnichName, ugnichPassword)))
.andExpect(status().isOk());
}
@Test
public void threadWithEphemeralNumberShouldReturn404() throws Exception {
mockMvc.perform(get("/api/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("/api/home")).andExpect(status().isUnauthorized());
mockMvc.perform(get("/api/auth"))
.andExpect(status().isUnauthorized());
mockMvc.perform(get("/api/auth").with(httpBasic(ugnichName, "wrongpassword")))
.andExpect(status().isUnauthorized());
MvcResult result = mockMvc.perform(get("/api/auth").with(httpBasic(ugnichName, ugnichPassword)))
.andExpect(status().isOk())
.andReturn();
String authHash = result.getResponse().getContentAsString();
assertThat(authHash, equalTo(ugnichHash));
mockMvc.perform(get("/api/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("/api/notifications").with(httpBasic(ugnichName, ugnichPassword))
.contentType(MediaType.APPLICATION_JSON_UTF8)
.content(jsonMapper.writeValueAsBytes(Collections.singletonList(registration))))
.andExpect(status().isOk());
MvcResult result = mockMvc.perform(get("/api/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/m/123456#23").build();
assertThat(uriComponents.getPath().substring(3), 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("/api/notifications").with(httpBasic(ugnichName, ugnichPassword))
.contentType(MediaType.APPLICATION_JSON_UTF8)
.content(jsonMapper.writeValueAsBytes(tokens))).andExpect(status().isForbidden());
mockMvc.perform(delete("/api/notifications").with(httpBasic(juickName, juickPassword))
.contentType(MediaType.APPLICATION_JSON_UTF8)
.content(jsonMapper.writeValueAsBytes(tokens))).andExpect(status().isOk());
}
@Test
public void notificationsSettingsAllowedOnlyForServiceUser() throws Exception {
CommandResult result = commandsManager.processCommand(ugnich, "yo", emptyUri);
String stringValueOfMid = String.valueOf(result.getNewMessage().get().getMid());
mockMvc.perform(get("/api/notifications").with(httpBasic(juickName, juickPassword))
.param("mid", stringValueOfMid).param("uid", String.valueOf(ugnich.getUid()))).andExpect(status().isOk());
mockMvc.perform(get("/api/notifications")
.param("mid", stringValueOfMid).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 -> {
User next = new User();
next.setUid(i);
messagesService.createReply(topmid, 0, next, "yo", null);
});
List topCandidates = messagesService.getPopularCandidates();
assertThat(topCandidates.size(), is(1));
assertThat(topCandidates.get(0), is(topmid));
Tag juickTag = tagService.getTag("juick", false);
assertThat(juickTag.TID, is(2));
tagService.updateTags(topmid, Collections.singletonList(juickTag));
assertThat(messagesService.getPopularCandidates().isEmpty(), is(true));
tagService.updateTags(topmid, Collections.singletonList(juickTag));
assertThat(messagesService.getPopularCandidates().isEmpty(), is(false));
jdbcTemplate.update("INSERT INTO tags(tag_id, name) VALUES(805, 'NSFW')");
Tag nsfw = tagService.getTag("NSFW", false);
assertThat(nsfw.TID, equalTo(805));
tagService.updateTags(topmid, Collections.singletonList(nsfw));
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 {
jdbcTemplate.execute("DELETE FROM users WHERE nick='renha'");
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(from);
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"));
String xml = "@yo:\n" +
"343432434\n" +
"\n" +
"#2 http://juick.com/2juick-2343432434@yo";
result = router.incomingMessage((rocks.xmpp.core.stanza.model.Message)server.parse(xml));
String active = "";
result = router.incomingMessage((rocks.xmpp.core.stanza.model.Message)server.parse(active));
xmppMessage.setFrom(botJid);
// TODO: assert events
}
@Test
public void botCommandsTests() throws Exception {
assertThat(commandsManager.processCommand(AnonymousUser.INSTANCE, "PING", emptyUri).getText(), is("PONG"));
// subscription commands have two lines, others have 1
assertThat(commandsManager.processCommand(AnonymousUser.INSTANCE, "help", emptyUri).getText().split("\n").length, is(32));
}
@Test
public void protocolTests() throws Exception {
int uid = userService.createUser("me", "secret");
User user = userService.getUserByUID(uid).orElse(AnonymousUser.INSTANCE);
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));
Message msg2 = yoyoMsg.getNewMessage().get();
int mid = msg2.getMid();
Timestamp last = jdbcTemplate.queryForObject("SELECT lastmessage FROM users WHERE id=?", Timestamp.class, user.getUid());
assertThat(last.toInstant(), equalTo(yoyoMsg.getNewMessage().get().getTimestamp()));
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);
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",
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, user, "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("number of subscribed users should match", 1,
subscriptionService.getUsersSubscribedToComments(
messagesService.getMessage(mid),
messagesService.getReply(mid, rid), true).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/m/" + mid + "#2";
String expectedThirdReply = "Reply posted.\n#" + mid + "/3 "
+ "https://juick.com/m/" + 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, " \t\n #" + mid + "/2 ",
URI.create("http://static.juick.com/settings/facebook.png")).getText());
Message reply = messagesService.getReplies(user, mid).stream().filter(m -> m.getRid() == 3).findFirst()
.orElse(new Message());
Timestamp lastreply = jdbcTemplate.queryForObject("SELECT lastmessage FROM users WHERE id=?", Timestamp.class, user.getUid());
assertThat(lastreply.toInstant(), equalTo(reply.getTimestamp()));
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());
assertThat(messagesService.getMessage(mid).getTags().size(), is(2));
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());
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);
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());
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());
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());
String expectedCodeMessage = "some smelly code goes here\n" +
"> void main(void** args) {\n" +
"> }";
String codeAndTags = "*code\n" + expectedCodeMessage;
Message codeAndTagsMessage = commandsManager.processCommand(user, codeAndTags, emptyUri).getNewMessage().get();
List codeAndTagsTags = codeAndTagsMessage.getTags();
assertEquals("expected single tag", 1,
codeAndTagsTags.size());
assertEquals("the single tag should be the 'code'", "code",
codeAndTagsTags.get(0).getName());
assertEquals("and the message should be with a C-code and without tags", expectedCodeMessage,
codeAndTagsMessage.getText());
CommandResult result = commandsManager.processCommand(user, "*one *two *three *four *five *six test", emptyUri);
assertThat(result.getNewMessage(), is(Optional.empty()));
assertThat(result.getText(), is("Sorry, 5 tags maximum."));
result = commandsManager.processCommand(user, String.format("#%d *one *two *three *four *five *six", msg.getMid()), emptyUri);
assertThat(result.getNewMessage(), is(Optional.empty()));
assertThat(result.getText(), is("Tags are NOT updated (5 tags maximum?)"));
result = commandsManager.processCommand(user, "I'm very smart to post my login url there" +
"", emptyUri);
assertThat(result.getNewMessage().isPresent(), is(true));
assertFalse(result.getNewMessage().get().getText().contains("VTYZkKV8FWkmu6g1"));
result = commandsManager.processCommand(user, "*корм *juick_ppl *рационализм *? *мюсли а сколько микроморт в дневной порции сверхмюслей?", emptyUri);
assertTrue(result.getNewMessage().isPresent());
String tags = "*Juick *Google *Google Play";
String data = "Вчера отправлял *NSFW постинг в топ :)";
result = commandsManager.processCommand(user, String.format("%s %s", tags, data), emptyUri);
assertThat(result.getNewMessage().get().getTags().size(), equalTo(3));
assertThat(result.getNewMessage().get().getText(), equalTo(data));
tags = "*\u041a\u0438\u0435\u0432 *\u044d\u043a\u043e\u043b\u043e\u0433\u0438\u044f";
data = "* \u043c\u0443\u0441\u043e\u0440\\n\u0423 \u043c\u0435\u043d\u044f \u043a\u0430\u0436\u0434\u0443\u044e \u043d\u0435\u0434\u0435\u043b\u044e \u0441\u043e\u0431\u0438\u0440\u0430\u0435\u0442\u0441\u044f \u043f\u043e 4-5 \u0431\u0443\u0442\u044b\u043b\u043e\u043a 1,5\u043b \u041f\u0415\u0422. \u041c\u043d\u0435 \u0433\u0435\u043c\u043e\u0440\u043d\u043e \u0441\u043e\u0431\u0438\u0440\u0430\u0442\u044c \u043f\u043e \u043a\u0438\u043b\u043e\u0433\u0440\u0430\u043c\u043c\u0443 \u0438\u043b\u0438 \u043f\u043e 5\u043a\u0433 \u044d\u0442\u043e\u0433\u043e \u043c\u0443\u0441\u043e\u0440\u0430, \u0447\u0442\u043e\u0431\u044b \u0432\u0435\u0437\u0442\u0438 \u0435\u0433\u043e \u0435\u0449\u0435 \u043a\u0443\u0434\u0430-\u0442\u043e.\\n\u041d\u0435, \u043d\u0443 \u0435\u0441\u0442\u044c \u043b\u044e\u0434\u0438, \u043a\u043e\u0442\u043e\u0440\u044b\u0435 \u0441\u043e\u0431\u0438\u0440\u0430\u044e\u0442 \u0432\u0442\u043e\u0440\u0441\u044b\u0440\u044c\u0435 \u043f\u043e \u043c\u0443\u0441\u043e\u0440\u043a\u0430\u043c, \u0441\u0432\u0430\u043b\u043a\u0430\u043c, \u043f\u043e\u0442\u043e\u043c\u0443 \u0447\u0442\u043e \u0434\u0435\u043d\u044c\u0433\u0438 \u043d\u0443\u0436\u043d\u044b. \u0418 \u0431\u044b\u0432\u0430\u044e\u0442 \u0441\u0442\u043e\u044f\u0442 \u043a\u043e\u043d\u0442\u0435\u0439\u043d\u0435\u0440\u044b-\u043a\u043b\u0435\u0442\u043a\u0438 \u0434\u043b\u044f \u043f\u043b\u0430\u0441\u0442\u0438\u043a\u0430, \u043d\u043e \u0442\u0430\u043a \u043a\u0430\u043a \u043c\u0443\u0441\u043e\u0440 \u0432\u044b\u0432\u043e\u0437\u044f\u0442 \u043d\u0435 \u0447\u0430\u0441\u0442\u043e \u0438\u043b\u0438 \u043b\u044e\u0434\u0438 \u0432\u043d\u0435\u0437\u0430\u043f\u043d\u043e \u0432\u044b\u043a\u0438\u0434\u044b\u0432\u0430\u044e\u0442 \u043c\u043d\u043e\u0433\u043e \u043c\u0443\u0441\u043e\u0440\u0430, \u0442\u043e \u0432 \u0442\u043e\u0439 \u043a\u043b\u0435\u0442\u043a\u0435 \u0442\u043e\u0442 \u043c\u0443\u0441\u043e\u0440, \u0447\u0442\u043e \u043d\u0435 \u043f\u043e\u043c\u0435\u0441\u0442\u0438\u043b\u0441\u044f \u0432 \u043e\u0431\u044b\u0447\u043d\u044b\u0445 \u043a\u043e\u043d\u0442\u0435\u0439\u043d\u0435\u0440\u0430\u0445.";
result = commandsManager.processCommand(user, String.format("%s %s", tags, data), emptyUri);
assertThat(result.getNewMessage().get().getTags().size(), equalTo(2));
assertThat(result.getNewMessage().get().getTags().get(0).getName(), equalTo("Киев"));
assertThat(result.getNewMessage().get().getText(), equalTo(data));
result = commandsManager.processCommand(user, "S @unknown-user", emptyUri);
assertThat(result.getNewMessage(), is(Optional.empty()));
assertThat(result.getText(), is("User not found"));
}
@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("/api/mail").with(httpBasic(juickName, juickPassword)).content(mail))
.andExpect(status().isOk());
}
@Test
public void recommendTests() 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("/api/like?mid=" + mid + "&hash=" + freefdHash))
.andExpect(status().isOk())
.andExpect(jsonPath("$.status", is("Message is added to your recommendations")));
mockMvc.perform(get("/api/thread?mid=" + mid + "&hash=" + freefdHash))
.andExpect(status().isOk())
.andExpect(jsonPath("$[0].recommendations.length()", is(1)))
.andExpect(jsonPath("$[0].recommendations[0]", is(freefdName)));
mockMvc.perform(post("/api/like?mid=" + freefdMid + "&hash=" + freefdHash))
.andExpect(status().isForbidden());
}
@Test
public void likesTests() throws Exception{
int user_id = userService.createUser("dsds", "secret");
String freefdHash = userService.getHashByUID(freefd.getUid());
int mid1 = messagesService.createMessage(user_id, "yo", null, new ArrayList<>());
mockMvc.perform(post("/api/react?mid=" + mid1 + "&hash=" + freefdHash+ "&reactionId=2"))
.andExpect(status().isOk());
Message msg4 = messagesService.getMessage(mid1);
assertThat(msg4.getLikes(), is(0));
assertThat(messagesService.getMessages(AnonymousUser.INSTANCE, Collections.singletonList(mid1)).get(0).getLikes(), is(0));
Assert.assertEquals(1, msg4.getReactions().stream().filter(r -> r.getId() == 2)
.findFirst().orElseThrow(IllegalStateException::new).getCount());
mockMvc.perform(post("/api/react?mid=" + mid1 + "&hash=" + freefdHash+ "&reactionId=1"))
.andExpect(status().isOk());
mockMvc.perform(post("/api/react?mid=" + mid1 + "&hash=" + freefdHash+ "&reactionId=1"))
.andExpect(status().isOk());
assertThat(messagesService.getMessage(mid1).getLikes(), is(1));
}
@Test
public void lastReadTests() throws Exception {
jdbcTemplate.execute("DELETE FROM bl_users");
assertThat(userService.isInBLAny(ugnich.getUid(), freefd.getUid()), is(false));
int mid = messagesService.createMessage(ugnich.getUid(), "to be watched", null, null);
subscriptionService.subscribeMessage(messagesService.getMessage(mid), ugnich);
messagesService.createReply(mid, 0, freefd, "new reply", null);
BiFunction lastRead = (user, m) -> jdbcTemplate.queryForObject(
"SELECT last_read_rid FROM subscr_messages WHERE suser_id=? AND message_id=?",
Integer.class, user.getUid(), m);
assertThat(lastRead.apply(ugnich, mid), is(0));
assertThat(messagesService.getUnread(ugnich).size(), is(1));
assertThat(messagesService.getUnread(ugnich).get(0), is(mid));
messagesService.getReplies(ugnich, mid);
assertThat(lastRead.apply(ugnich, mid), is(1));
assertThat(messagesService.getUnread(ugnich).size(), is(0));
messagesService.setLastReadComment(ugnich, mid, 0);
assertThat(lastRead.apply(ugnich, mid), is(1));
String ugnichHash = userService.getHashByUID(ugnich.getUid());
int freefdrid = messagesService.createReply(mid, 0, freefd, "again", null);
mockMvc.perform(get(String.format("/api/thread/mark_read/%d-%d.gif?hash=%s", mid, freefdrid, ugnichHash)))
.andExpect(status().isOk())
.andExpect(content().bytes(IOUtils.toByteArray(
Objects.requireNonNull(getClass().getClassLoader().getResource("Transparent.gif")))));
assertThat(lastRead.apply(ugnich, mid), is(freefdrid));
privacyQueriesService.blacklistUser(ugnich, freefd);
int newfreefdrid = messagesService.createReply(mid, 0, freefd, "from ban", null);
serverManager.processMessageEvent(new MessageEvent(this, messagesService.getReply(mid, newfreefdrid),
Collections.emptyList()));
assertThat(userService.isReplyToBL(ugnich, messagesService.getReply(mid, newfreefdrid)), is(true));
assertThat(lastRead.apply(ugnich, mid), is(newfreefdrid));
privacyQueriesService.blacklistUser(ugnich, freefd);
newfreefdrid = messagesService.createReply(mid, 0, freefd, "after ban", null);
assertThat(lastRead.apply(ugnich, mid), lessThan(newfreefdrid));
mockMvc.perform(get(String.format("/api/thread?mid=%d&hash=%s", mid, ugnichHash)))
.andExpect(status().isOk());
assertThat(lastRead.apply(ugnich, mid), is(newfreefdrid));
}
@Test
public void feedsShouldNotContainMessagesWithBannedTags() {
Tag banned = tagService.getTag("banned", true);
int mid = messagesService.createMessage(ugnich.getUid(), "yo", "jpg",
Collections.singletonList(banned));
privacyQueriesService.blacklistTag(freefd, banned);
assertTrue(messagesService.getMessages(AnonymousUser.INSTANCE, messagesService.getAll(freefd.getUid(), 0))
.stream().noneMatch(m -> m.getTags().contains(banned)));
assertFalse(messagesService.getMessages(AnonymousUser.INSTANCE, messagesService.getAll(ugnich.getUid(), 0))
.stream().noneMatch(m -> m.getTags().contains(banned)));
assertTrue(messagesService.getMessages(AnonymousUser.INSTANCE, messagesService.getPhotos(freefd.getUid(), 0))
.stream().noneMatch(m -> m.getTags().contains(banned)));
assertFalse(messagesService.getMessages(AnonymousUser.INSTANCE, messagesService.getPhotos(ugnich.getUid(), 0))
.stream().noneMatch(m -> m.getTags().contains(banned)));
jdbcTemplate.update("UPDATE messages SET popular=1 WHERE message_id=?", mid);
assertTrue(messagesService.getMessages(AnonymousUser.INSTANCE, messagesService.getPopular(freefd.getUid(), 0))
.stream().noneMatch(m -> m.getTags().contains(banned)));
assertFalse(messagesService.getMessages(AnonymousUser.INSTANCE, messagesService.getPopular(ugnich.getUid(), 0))
.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("newUser", "12345");
int newMid = messagesService.createMessage(newUid, "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).getTags().size(), is(0));
privacyQueriesService.blacklistUser(freefd, userService.getUserByUID(newUid).orElse(AnonymousUser.INSTANCE));
assertTrue(messagesService.getMessages(AnonymousUser.INSTANCE, messagesService.getMyFeed(freefd.getUid(), 0, true))
.stream().noneMatch(m -> m.getMid() == newMid));
}
@Test
public void tagsShouldBeDeserializedFromXml() throws JAXBException {
XmppSessionConfiguration configuration = XmppSessionConfiguration.builder()
.extensions(Extension.of(com.juick.Message.class))
.build();
XmppSession xmpp = new XmppSession("juick.com", configuration) {
@Override
public void connect(Jid from) {
}
@Override
public Jid getConnectedResource() {
return null;
}
};
String tag = "yo";
String xml = "yoyoyopeople";
Unmarshaller unmarshaller = xmpp.createUnmarshaller();
rocks.xmpp.core.stanza.model.Message xmppMessage = (rocks.xmpp.core.stanza.model.Message) unmarshaller.unmarshal(new StringReader(xml));
Tag xmlTag = (Tag) unmarshaller.unmarshal(new StringReader(tag));
assertThat(xmlTag.getName(), equalTo("yo"));
Message juickMessage = xmppMessage.getExtension(Message.class);
assertThat(juickMessage.getTags().get(0).getName(), equalTo("yo"));
}
@Test
public void messageParserSerializer() throws ParserConfigurationException,
IOException, SAXException, JAXBException {
Message msg = new Message();
msg.setTags(MessageUtils.parseTags("test test" + (char) 0xA0 + "2 test3"));
assertEquals("First tag must be", "test", msg.getTags().get(0).getName());
assertEquals("Third tag must be", "test3", msg.getTags().get(2).getName());
assertEquals("Count of tags must be", 3, msg.getTags().size());
Instant currentDate = Instant.now();
msg.setTimestamp(currentDate);
String jsonMessage = jsonMapper.writeValueAsString(msg);
assertEquals("date should be in timestamp field", DateFormattersHolder.getMessageFormatterInstance().format(currentDate),
JsonPath.read(jsonMessage, "$.timestamp"));
JAXBContext context = JAXBContext
.newInstance(Message.class);
Marshaller m = context.createMarshaller();
StringWriter sw = new StringWriter();
m.marshal(msg, sw);
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.parse(new ByteArrayInputStream(sw.toString().getBytes(CharEncoding.UTF_8)));
Node juickNode = doc.getElementsByTagName("juick").item(0);
NamedNodeMap attrs = juickNode.getAttributes();
assertEquals("date should be in ts field", DateFormattersHolder.getMessageFormatterInstance().format(currentDate),
attrs.getNamedItem("ts").getNodeValue());
}
@Test
public void restTemplateTests() {
HttpHeaders headers = new HttpHeaders();
headers.setContentType(MediaType.APPLICATION_FORM_URLENCODED);
MultiValueMap map= new LinkedMultiValueMap<>();
HttpEntity> request = new HttpEntity<>(map, headers);
map.add("body", "yo");
map.add("hash", userService.getHashByUID(ugnich.getUid()));
ResponseEntity result = restTemplate.postForEntity(
"/api/post",
request, CommandResult.class);
assertThat(result.getStatusCode(), is(HttpStatus.OK));
}
@Test
public void emptyAuthenticatedPostShouldThrowBadRequest() throws Exception {
mockMvc.perform(post("/api/post")
.with(httpBasic(juickName, juickPassword)))
.andExpect(status().isBadRequest());
}
@Test
public void attachmentSizeTests() throws URISyntaxException, IOException {
ImageUtils imageUtils = new ImageUtils(StringUtils.EMPTY, StringUtils.EMPTY);
Attachment attachment = imageUtils.getAttachment(new File(getClass().getClassLoader().getResource("Transparent.gif").toURI()));
assertThat(attachment.getHeight(), is(1));
assertThat(attachment.getWidth(), is(1));
}
@Test
public void meContainsAllInfo() throws Exception {
jdbcTemplate.update("DELETE FROM subscr_users");
assertThat(userService.getUserReaders(ugnich.getUid()).size(), is(0));
assertThat(userService.getUserFriends(ugnich.getUid()).size(), is(0));
commandsManager.processCommand(freefd, "S @ugnich", emptyUri);
commandsManager.processCommand(ugnich, "S @freefd", emptyUri);
assertThat(userService.getUserReaders(ugnich.getUid()).size(), is(1));
String hash = userService.getHashByUID(ugnich.getUid());
mockMvc.perform(get("/api/me")
.with(httpBasic(ugnichName, ugnichPassword)))
.andExpect(jsonPath("$.hash", is(hash)))
.andExpect(jsonPath("$.readers.length()", is(1)))
.andExpect(jsonPath("$.read.length()", is(1)));
}
@Test
public void feedsShouldNotContainBannedUsers() throws Exception {
commandsManager.processCommand(ugnich, "BL @freefd", emptyUri);
CommandResult result = commandsManager.processCommand(ugnich, "freefd - dick", emptyUri);
int mid = result.getNewMessage().get().getMid();
commandsManager.processCommand(freefd, String.format("#%d ugnich - dick too", mid), emptyUri);
commandsManager.processCommand(juick, String.format("#%d/1 ban for a hour!", mid), emptyUri);
commandsManager.processCommand(juick, String.format("#%d freefd is here but it is hidden from you", mid), emptyUri);
assertThat(messagesService.getMessage(mid).getReplies(), is(3));
Message reply = messagesService.getReply(mid, 3);
assertThat(userService.isReplyToBL(ugnich, reply), is(false));
List replies = messagesService.getReplies(ugnich, mid);
assertThat(replies.size(), is(1));
commandsManager.processCommand(freefd, String.format("#%d/3 hahaha!", mid), emptyUri);
assertThat(messagesService.getMessage(mid).getReplies(), is(4));
replies = messagesService.getReplies(ugnich, mid);
assertThat(replies.size(), is(1));
commandsManager.processCommand(juick, String.format("#%d/4 mmm?!", mid), emptyUri);
assertThat(messagesService.getMessage(mid).getReplies(), is(5));
replies = messagesService.getReplies(ugnich, mid);
reply = messagesService.getReply(mid, 5);
assertThat(userService.isReplyToBL(ugnich, reply), is(true));
assertThat(replies.size(), is(1));
List msgs = messagesService.getMessages(ugnich, Collections.singletonList(mid));
assertThat(msgs.get(0).getReplies(), is(1));
commandsManager.processCommand(ugnich, "BL @freefd", emptyUri);
messagesService.setRead(ugnich, mid);
assertThat(messagesService.getReplies(ugnich, mid).size(), is(5));
List nonblmsgs = messagesService.getMessages(ugnich, Collections.singletonList(mid));
assertThat(nonblmsgs.get(0).getReplies(), is(5));
commandsManager.processCommand(ugnich, "BL @freefd", emptyUri);
Tag tag = tagService.getTag("linux", true);
messagesService.createMessage(freefd.getUid(), "sux", null, Collections.singletonList(tag));
assertThat(messagesService.getTag(tag.TID, freefd.getUid(), 0, 10).size(), is(1));
assertThat(messagesService.getTag(tag.TID, ugnich.getUid(), 0, 10).size(), is(0));
commandsManager.processCommand(ugnich, "BL @freefd", emptyUri);
}
@Test
public void cmykJpegShouldBeProcessedCorrectly() throws Exception {
CommandResult postJpgCmyk = commandsManager.processCommand(ugnich, "YO", URI.create("classpath:cmyk.jpg"));
assertThat(postJpgCmyk.getNewMessage().isPresent(), is(true));
int mid = postJpgCmyk.getNewMessage().get().getMid();
File originalFile = Paths.get(imgDir, "p", String.format("%d.jpg", mid)).toFile();
assertThat(originalFile.exists(), is(true));
File mediumFile = Paths.get(imgDir, "photos-1024", String.format("%d.jpg", mid)).toFile();
assertThat(mediumFile.exists(), is(true));
assertThat(postJpgCmyk.getNewMessage().get().getAttachment().getWidth(), is(2585));
assertThat(postJpgCmyk.getNewMessage().get().getAttachment().getHeight(), is(3335));
assertThat(postJpgCmyk.getNewMessage().get().getAttachment().getMedium().getHeight(), is(1024));
assertThat(postJpgCmyk.getNewMessage().get().getAttachment().getSmall().getHeight(), is(512));
}
@Test
public void JpegWithoutJfifShouldBeProcessedCorrectly() throws Exception {
CommandResult postJpgCmyk = commandsManager.processCommand(ugnich, "YO", URI.create("classpath:nojfif.jpg"));
assertThat(postJpgCmyk.getNewMessage().isPresent(), is(true));
int mid = postJpgCmyk.getNewMessage().get().getMid();
File originalFile = Paths.get(imgDir, "p", String.format("%d.jpg", mid)).toFile();
assertThat(originalFile.exists(), is(true));
File mediumFile = Paths.get(imgDir, "photos-1024", String.format("%d.jpg", mid)).toFile();
assertThat(mediumFile.exists(), is(true));
assertThat(postJpgCmyk.getNewMessage().get().getAttachment().getWidth(), is(3264));
assertThat(postJpgCmyk.getNewMessage().get().getAttachment().getHeight(), is(2448));
assertThat(postJpgCmyk.getNewMessage().get().getAttachment().getMedium().getHeight(), is(768));
assertThat(postJpgCmyk.getNewMessage().get().getAttachment().getSmall().getHeight(), is(384));
}
@Test
public void JpegFromJuickUriShouldBeProcessedCorrectly() throws Exception {
Path tmpFile = Paths.get(tmpDir, "2915104.jpg");
Files.copy(Paths.get(ClassLoader.getSystemResource("2915104.jpg").toURI()), tmpFile, StandardCopyOption.REPLACE_EXISTING);
assertThat(tmpFile.toFile().exists(), is(true));
CommandResult postJpgiPhone = commandsManager.processCommand(ugnich, "YO", URI.create("juick://2915104.jpg"));
assertThat(postJpgiPhone.getNewMessage().isPresent(), is(true));
int mid = postJpgiPhone.getNewMessage().get().getMid();
File originalFile = Paths.get(imgDir, "p", String.format("%d.jpg", mid)).toFile();
assertThat(originalFile.exists(), is(true));
File mediumFile = Paths.get(imgDir, "photos-1024", String.format("%d.jpg", mid)).toFile();
assertThat(mediumFile.exists(), is(true));
assertThat(postJpgiPhone.getNewMessage().get().getAttachment().getWidth(), is(1280));
assertThat(postJpgiPhone.getNewMessage().get().getAttachment().getHeight(), is(1280));
assertThat(postJpgiPhone.getNewMessage().get().getAttachment().getMedium().getHeight(), is(1024));
assertThat(postJpgiPhone.getNewMessage().get().getAttachment().getSmall().getHeight(), is(512));
}
@Test
public void changeExtensionWhenReceiveFileWithWrongContentType() throws Exception {
Path pngOutput = Paths.get(tmpDir, "cmyk.png");
Files.deleteIfExists(pngOutput);
Files.copy(getClass().getClassLoader().getResourceAsStream("cmyk.jpg"), pngOutput);
assertThat(pngOutput.toFile().exists(), is(true));
CommandResult postJpgCmyk = commandsManager.processCommand(ugnich, "YO", pngOutput.toUri());
assertThat(postJpgCmyk.getNewMessage().isPresent(), is(true));
assertThat(postJpgCmyk.getNewMessage().get().getAttachmentType(), is("jpg"));
CommandResult replyJpgCmyk = commandsManager.processCommand(ugnich, String.format("#%d YO", postJpgCmyk.getNewMessage().get().getMid()), pngOutput.toUri());
assertThat(replyJpgCmyk.getNewMessage().isPresent(), is(true));
assertThat(replyJpgCmyk.getNewMessage().get().getAttachmentType(), is("jpg"));
}
@Test
public void messageEditingSpec() throws Exception {
MvcResult result = mockMvc.perform(post("/api/post").with(httpBasic(ugnichName, ugnichPassword))
.param("body", "YO")).andExpect(status().is2xxSuccessful()).andReturn();
Message original = jsonMapper.readValue(result.getResponse().getContentAsString(), CommandResult.class)
.getNewMessage().get();
assertThat(original.getText(), equalTo("YO"));
assertThat(original.getUpdatedAt(), equalTo(original.getTimestamp()));
// to have updated_at greater than ts
Thread.sleep(1000);
result = mockMvc.perform(post("/api/update").with(httpBasic(ugnichName, ugnichPassword))
.param("mid", String.valueOf(original.getMid()))
.param("body", "PEOPLE")).andExpect(status().is2xxSuccessful()).andReturn();
Message edited = jsonMapper.readValue(result.getResponse().getContentAsString(), CommandResult.class)
.getNewMessage().get();
assertThat(edited.getText(), equalTo("PEOPLE"));
assertThat(edited.getUpdatedAt(), greaterThan(edited.getTimestamp()));
mockMvc.perform(post("/api/update").with(httpBasic(freefdName, freefdPassword))
.param("mid", String.valueOf(original.getMid()))
.param("body", "PEOPLE")).andExpect(status().is(403));
result = mockMvc.perform(post("/api/comment").with(httpBasic(freefdName, freefdPassword))
.param("mid", String.valueOf(original.getMid()))
.param("body", "HEY")).andExpect(status().is2xxSuccessful()).andReturn();
CommandResult comment = jsonMapper.readValue(result.getResponse().getContentAsString(), CommandResult.class);
assertThat(comment.getNewMessage().get().getText(), is("HEY"));
assertThat(comment.getNewMessage().get().getUpdatedAt(), is(comment.getNewMessage().get().getTimestamp()));
// to have updated_at greater than ts
Thread.sleep(1000);
result = mockMvc.perform(post("/api/update").with(httpBasic(freefdName, freefdPassword))
.param("mid", String.valueOf(comment.getNewMessage().get().getMid()))
.param("rid", String.valueOf(comment.getNewMessage().get().getRid()))
.param("body", "HEY, JOE")).andExpect(status().is2xxSuccessful()).andReturn();
Message editedComment = jsonMapper.readValue(result.getResponse().getContentAsString(), CommandResult.class)
.getNewMessage().get();
assertThat(editedComment.getText(), is("HEY, JOE"));
assertThat(editedComment.getUpdatedAt(), greaterThan(editedComment.getTimestamp()));
messagesService.deleteMessage(ugnich.getUid(), original.getMid());
}
@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");
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);
BiFunction> subscribers = (recommId, msg) ->
subscriptionService.getUsersSubscribedToUserRecommendations(recommId, msg);
List recommendSubscribers = subscribers.apply(recommenderId, messagesService.getMessage(posterMid));
assertThat(recommendSubscribers.size(), is(1));
assertThat(recommendSubscribers.get(0).getUid(), is(readerId));
privacyQueriesService.blacklistUser(reader, poster);
assertThat(subscribers.apply(recommenderId, messagesService.getMessage(posterMid)).size(), is(0));
privacyQueriesService.blacklistUser(reader, poster);
assertThat(subscribers.apply(recommenderId, messagesService.getMessage(posterMid)).size(), is(1));
tagService.blacklistTag(reader, sampleTag);
assertThat(subscribers.apply(recommenderId, messagesService.getMessage(posterMid)).size(), is(0));
tagService.blacklistTag(reader, sampleTag);
assertThat(subscribers.apply(recommenderId, messagesService.getMessage(posterMid)).size(), is(1));
messagesService.recommendMessage(posterMid, lateRecommenderId);
List lateRecommendSubscribers = subscribers.apply(recommenderId, messagesService.getMessage(posterMid));
assertThat(lateRecommendSubscribers.size(), is(0));
int readerMid = messagesService.createMessage(readerId, "PEOPLE", null, null);
messagesService.recommendMessage(readerMid, recommenderId);
assertThat(subscribers.apply(recommenderId, messagesService.getMessage(readerMid)).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);
Message msg = messagesService.getMessage(mid);
int rid = messagesService.createReply(mid, 0, commenter,
"@mmm is dick", null);
Message reply = messagesService.getReply(mid, rid);
assertThat(subscriptionService.getUsersSubscribedToComments(msg, reply).size(), is(1));
subscriptionService.subscribeUser(mentioner, commenter);
assertThat(subscriptionService.getUsersSubscribedToComments(msg, reply).size(), is(1));
privacyQueriesService.blacklistUser(mentioner, commenter);
assertThat(subscriptionService.getUsersSubscribedToComments(msg, reply).size(), is(0));
}
@Test
public void xmppStatusApi() throws Exception {
Supplier getStatus = () -> {
try {
MvcResult result = mockMvc.perform(get("/api/xmpp-status").with(httpBasic(ugnichName, ugnichPassword)))
.andExpect(status().isOk()).andReturn();
return jsonMapper.readValue(result.getResponse().getContentAsString(), XMPPStatus.class);
} catch (Exception e) {
e.printStackTrace();
return null;
}
};
assertThat(getStatus.get().getInbound().size(), is(0));
ConnectionIn test = new ConnectionIn(server, new Socket("localhost", server.getServerPort()));
test.from.add(Jid.of("test"));
server.getInConnections().clear();
server.addConnectionIn(test);
assertThat(getStatus.get().getInbound().size(), is(1));
}
@Test
public void credentialsShouldNeverBeSerialized() throws Exception {
int uid = userService.createUser("yyy", "xxxx");
User yyy = userService.getUserByUID(uid).get();
assertThat(yyy.getCredentials(), is("xxxx"));
ObjectMapper jsonMapper = new ObjectMapper();
jsonMapper.setSerializationInclusion(JsonInclude.Include.NON_DEFAULT);
String jsonUser = jsonMapper.writeValueAsString(yyy);
Map user = JsonPath.read(jsonUser, "$");
// only uid and name
assertThat(user.keySet().size(), is(2));
JAXBContext context = JAXBContext
.newInstance(User.class);
Marshaller m = context.createMarshaller();
StringWriter sw = new StringWriter();
m.marshal(yyy, sw);
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document doc = db.parse(new ByteArrayInputStream(sw.toString().getBytes(StandardCharsets.UTF_8)));
Element juickNode = doc.getDocumentElement();
NamedNodeMap attrs = juickNode.getAttributes();
// uid, name, xmlns, xmlns:user
assertThat(attrs.getLength(), is(4));
}
@Test
public void bannedUserBlogandPostShouldReturn404() throws Exception {
String userName = "isilmine";
String userPassword = "secret";
String msgText = "автор этого поста был забанен";
User isilmine = userService.getUserByUID(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());
jdbcTemplate.update("UPDATE users SET banned=1 WHERE id=?", isilmine.getUid());
mockMvc.perform(get(String.format("/api/thread?mid=%d", mid)).with(httpBasic(ugnichName, ugnichPassword)))
.andExpect(status().isNotFound());
mockMvc.perform(get("/api/messages?uname=isilmine").with(httpBasic(ugnichName, ugnichPassword)))
.andExpect(status().isNotFound());
mockMvc.perform(get("/api/info/isilmine").with(httpBasic(ugnichName, ugnichPassword)))
.andExpect(status().isNotFound());
mockMvc.perform(get("/api/info/ugnich").with(httpBasic(ugnichName, ugnichPassword)))
.andExpect(status().isOk());
}
@Test
public void emptyPasswordMeansUserIsDisabled() throws Exception {
String userName = "oldschooluser";
String userPassword = "";
userService.createUser(userName, userPassword);
mockMvc.perform(get("/api/auth").with(httpBasic(userName, userPassword))).andExpect(status().isUnauthorized());
mockMvc.perform(post("/login")
.param("username", userName)
.param("password", userPassword)).andExpect(status().is3xxRedirection())
.andExpect(redirectedUrl("/login?error=1"));
}
@Test
public void bannedUserShouldBeShadowedFromRecommendationsList() throws IOException {
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));
assertThat(messagesService.getMessage(mid).getLikes(), is(3));
assertThat(CollectionUtils.isEqualCollection(messagesService.getMessageRecommendations(mid), Arrays.asList("fmap", "ermine", "pogo")), is(true));
privacyQueriesService.blacklistUser(userService.getUserByName("monstreek"), userService.getUserByName("pogo"));
assertThat(messagesService.getMessage(mid).getLikes(), is(3));
assertThat(CollectionUtils.isEqualCollection(messagesService.getMessageRecommendations(mid), Arrays.asList("fmap", "ermine")), is(true));
}
@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));
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());
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);
assertThat(messagesService.getReplies(AnonymousUser.INSTANCE, mid).size(), is(1));
assertThat(messagesService.getMessages(AnonymousUser.INSTANCE, Collections.singletonList(mid)).get(0).getReplies(), is(1));
assertThat(messagesService.getReplies(banned, mid).size(), is(2));
assertThat(messagesService.getMessages(banned, Collections.singletonList(mid)).get(0).getReplies(), is(2));
}
@Test
public void accountUrlShouldBeExposedOverWebfinger() throws Exception {
mockMvc.perform(get("/.well-known/webfinger?resource=acct:ugnich@localhost"))
.andExpect(status().isOk())
.andExpect(jsonPath("$.subject", is("acct:ugnich@localhost")))
.andExpect(jsonPath("$.links", hasSize(1)))
.andExpect(jsonPath("$.links[0].href", is("http://localhost:8080/u/ugnich")));
mockMvc.perform(get("/.well-known/webfinger?resource=acct:durov@localhost"))
.andExpect(status().isNotFound());
}
@Test
public void userProfileAndBlogShouldBeExposedAsActivityStream() throws Exception {
mockMvc.perform(get("/u/ugnich").accept(ActivityObject.LD_JSON_MEDIA_TYPE))
.andExpect(status().isOk())
.andExpect(jsonPath("$.icon.url", is("http://localhost:8080/i/a/1.png")))
.andExpect(jsonPath("$.publicKey.publicKeyPem", is(keystoreManager.getPublicKey())));
jdbcTemplate.execute("DELETE FROM messages");
List mids = IteratorUtils.toList(IntStream.rangeClosed(1, 30)
.mapToObj(i -> messagesService.createMessage(ugnich.getUid(),
String.format("message %d", i), null, null))
.collect(Collectors.toCollection(ArrayDeque::new)).descendingIterator());
List midsPage = mids.stream().limit(20).collect(Collectors.toList());
mockMvc.perform(get("/u/ugnich/blog").accept(ActivityObject.ACTIVITY_JSON_MEDIA_TYPE))
.andExpect(status().isOk())
.andExpect(jsonPath("$.orderedItems", hasSize(20)))
.andExpect(jsonPath("$.next", is("http://localhost:8080/u/ugnich/blog?before=" + midsPage.get(midsPage.size() - 1))));
}
@Test
public void postWithoutTagsShouldNotHaveAsteriskInTitle() throws Exception {
String msgText = "Привет, я - Угнич";
int mid = messagesService.createMessage(ugnich.getUid(), msgText, null, null);
HtmlPage threadPage = webClient.getPage(String.format("http://localhost:8080/ugnich/%d", mid));
assertThat(threadPage.getTitleText(), equalTo("ugnich:"));
}
@Test
public void repliesList() throws IOException {
int mid = messagesService.createMessage(ugnich.getUid(), "hello", null, null);
IntStream.range(1, 15).forEach(i ->
messagesService.createReply(mid, i-1, freefd, String.valueOf(i-1), null ));
HtmlPage threadPage = webClient.getPage(String.format("http://localhost:8080/ugnich/%d", mid));
assertThat(threadPage.getWebResponse().getStatusCode(), equalTo(200));
Long visibleItems = StreamSupport.stream(threadPage.getHtmlElementById("replies")
.getChildElements().spliterator(), false).filter(e -> {
StyleElement display = e.getStyleElement("display");
return display == null || !display.getValue().equals("none");
}).count();
assertThat(visibleItems, equalTo(14L));
}
@Test
public void userShouldNotSeeReplyButtonToBannedUser() throws Exception {
int mid = messagesService.createMessage(ugnich.getUid(), "freefd bl me", null, null);
messagesService.createReply(mid, 0, ugnich, "yo", null);
MvcResult loginResult = mockMvc.perform(post("/login")
.param("username", freefdName)
.param("password", freefdPassword))
.andExpect(status().isFound()).andReturn();
Cookie loginCookie = loginResult.getResponse().getCookie("juick-remember-me");
webClient.setCookieManager(new CookieManager());
webClient.getCookieManager().addCookie(
new com.gargoylesoftware.htmlunit.util.Cookie(loginCookie.getDomain(),
loginCookie.getName(),
loginCookie.getValue()));
HtmlPage 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(false));
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);
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));
assertThat(threadPage.querySelectorAll(".a-thread-comment").isEmpty(), equalTo(true));
}
@Test
public void correctTagsEscaping() throws PebbleException, IOException {
PebbleTemplate template = pebbleEngine.getTemplate("views/test");
Writer writer = new StringWriter();
template.evaluate(writer,
Collections.singletonMap("tagsList",
Collections.singletonList(StringEscapeUtils.escapeHtml4(new Tag(">_<").getName()))));
String output = writer.toString().trim();
assertThat(output, equalTo(">_<"));
}
public DomElement fetchMeta(String url, String name) throws IOException {
HtmlPage page = webClient.getPage(url);
DomElement emptyMeta = new DomElement("", "meta", null, null);
return page.getElementsByTagName("meta").stream()
.filter(t -> t.getAttribute("name").equals(name)).findFirst().orElse(emptyMeta);
}
@Test
public void testTwitterCards() throws Exception {
int mid = messagesService.createMessage(ugnich.getUid(), "without image", null, null);
assertThat(fetchMeta(String.format("http://localhost:8080/ugnich/%d", mid), "twitter:card")
.getAttribute("content"), equalTo("summary"));
int mid2 = messagesService.createMessage(ugnich.getUid(), "with image", "png", null);
Message message = messagesService.getMessage(mid2);
assertThat(fetchMeta(String.format("http://localhost:8080/ugnich/%d", mid2), "twitter:card")
.getAttribute("content"), equalTo("summary_large_image"));
assertThat(fetchMeta(String.format("http://localhost:8080/ugnich/%d", mid2), "og:description")
.getAttribute("content"),
startsWith(StringEscapeUtils.escapeHtml4(MessageUtils.getMessageHashTags(message))));
}
@Test
public void hashLoginShouldNotUseSession() throws Exception {
String hash = userService.getHashByUID(ugnich.getUid());
MvcResult hashLoginResult = mockMvc.perform(get("/?show=my&hash=" + hash))
.andExpect(status().isOk())
.andExpect(model().attribute("visitor", hasProperty("authHash", equalTo(hash))))
.andExpect(content().string(containsString(hash)))
.andReturn();
Cookie rememberMeFromHash = hashLoginResult.getResponse().getCookie("juick-remember-me");
MvcResult formLoginResult = mockMvc.perform(post("/login")
.param("username", ugnichName)
.param("password", ugnichPassword))
.andExpect(status().is3xxRedirection()).andReturn();
Cookie rememberMeFromForm = formLoginResult.getResponse().getCookie("juick-remember-me");
mockMvc.perform(get("/?show=my").cookie(rememberMeFromForm)).andExpect(status().isOk())
.andExpect(model().attribute("visitor", hasProperty("authHash", equalTo(hash))))
.andExpect(content().string(containsString(hash)));
mockMvc.perform(get("/?show=my").cookie(rememberMeFromHash)).andExpect(status().isOk())
.andExpect(model().attribute("visitor", hasProperty("authHash", equalTo(hash))))
.andExpect(content().string(containsString(hash)));
}
@Test
public void nonExistentBlogShouldReturn404() throws Exception {
mockMvc.perform(get("/ololoe/")).andExpect(status().isNotFound());
}
@Test
public void discussionsShouldBePageableByTimestamp() throws Exception {
String msgText = "Привет, я снова Угнич";
int mid = messagesService.createMessage(ugnich.getUid(), msgText, null, null);
int midNew = messagesService.createMessage(ugnich.getUid(), "Я более новый Угнич", null, null);
MvcResult loginResult = mockMvc.perform(post("/login")
.param("username", freefdName)
.param("password", freefdPassword))
.andExpect(status().is3xxRedirection()).andReturn();
Cookie loginCookie = loginResult.getResponse().getCookie("juick-remember-me");
webClient.setCookieManager(new CookieManager());
webClient.getCookieManager().addCookie(
new com.gargoylesoftware.htmlunit.util.Cookie(loginCookie.getDomain(),
loginCookie.getName(),
loginCookie.getValue()));
String discussionsUrl = "http://localhost:8080/";
HtmlPage discussions = webClient.getPage(discussionsUrl);
assertThat(discussions.querySelectorAll("article").size(), is(0));
subscriptionService.subscribeMessage(messagesService.getMessage(mid), freefd);
discussions = (HtmlPage) discussions.refresh();
assertThat(discussions.querySelectorAll("article").size(), is(1));
subscriptionService.subscribeMessage(messagesService.getMessage(midNew), freefd);
discussions = (HtmlPage) discussions.refresh();
assertThat(discussions.querySelectorAll("article").size(), is(2));
assertThat(discussions.querySelectorAll("article").get(0).getAttributes().getNamedItem("data-mid").getNodeValue(), is(String.valueOf(midNew)));
messagesService.createReply(mid, 0, freefd, "I'm replied", null);
discussions = (HtmlPage) discussions.refresh();
assertThat(discussions.querySelectorAll("article").size(), is(2));
assertThat(discussions.querySelectorAll("article").get(0).getAttributes().getNamedItem("data-mid").getNodeValue(), is(String.valueOf(mid)));
Message msg = messagesService.getMessage(mid);
HtmlPage discussionsOld = webClient.getPage(discussionsUrl + "?to=" + msg.getUpdated().toEpochMilli());
assertThat(discussionsOld.querySelectorAll("article").size(), is(1));
assertThat(discussionsOld.querySelectorAll("article").get(0).getAttributes().getNamedItem("data-mid").getNodeValue(), is(String.valueOf(midNew)));
List newMids = IntStream.rangeClosed(1, 19).map(i -> messagesService.createMessage(ugnich.getUid(), String.valueOf(i), null, null)).boxed().collect(Collectors.toList());
for (Integer m : newMids) {
subscriptionService.subscribeMessage(messagesService.getMessage(m), freefd);
}
discussions = (HtmlPage) discussions.refresh();
assertThat(discussions.querySelectorAll("article").size(), is(20));
assertThat(discussions.querySelectorAll("article")
.get(19).getAttributes().getNamedItem("data-mid").getNodeValue(), is(String.valueOf(mid)));
messagesService.createReply(midNew, 0, freefd, "I'm replied", null);
discussions = (HtmlPage) discussions.refresh();
assertThat(discussions.querySelectorAll("article")
.get(0).getAttributes().getNamedItem("data-mid").getNodeValue(), is(String.valueOf(midNew)));
Message old = messagesService.getMessage(newMids.get(0));
discussionsOld = webClient.getPage(discussionsUrl + "?to=" + old.getUpdated().toEpochMilli());
assertThat(discussionsOld.querySelectorAll("article").size(), is(1));
assertThat(discussionsOld.querySelectorAll("article")
.get(0).getAttributes().getNamedItem("data-mid").getNodeValue(), is(String.valueOf(mid)));
}
@Test
public void redirectParamShouldCorrectlyRedirectLoggedUser() throws Exception {
MvcResult formLoginResult = mockMvc.perform(post("/login")
.param("username", ugnichName)
.param("password", ugnichPassword))
.andExpect(status().isFound()).andReturn();
Cookie rememberMeFromForm = formLoginResult.getResponse().getCookie("juick-remember-me");
mockMvc.perform(get("/login").cookie(rememberMeFromForm))
.andExpect(status().is3xxRedirection())
.andExpect(redirectedUrl("/"));
mockMvc.perform(get("/login?redirect=false").cookie(rememberMeFromForm))
.andExpect(status().is3xxRedirection())
.andExpect(redirectedUrl("/login/success"));
}
@Test
public void anythingRedirects() throws Exception {
int mid = messagesService.createMessage(ugnich.getUid(), "yo", null, null);
mockMvc.perform(get(String.format("/%d", mid)))
.andExpect(status().isMovedPermanently())
.andExpect(redirectedUrl(String.format("/%s/%d", ugnich.getName(), mid)));
}
@Test
public void appAssociationsTest() throws Exception {
mockMvc.perform((get("/.well-known/apple-app-site-association")))
.andExpect(status().isOk())
.andExpect(content().contentType(MediaType.APPLICATION_JSON_UTF8))
.andExpect(jsonPath("$.webcredentials.apps[0]", is(appId)));
}
@Test
public void notificationsTests() throws Exception {
MvcResult loginResult = mockMvc.perform(post("/login")
.param("username", freefdName)
.param("password", freefdPassword))
.andExpect(status().is3xxRedirection()).andReturn();
Cookie loginCookie = loginResult.getResponse().getCookie("juick-remember-me");
webClient.setCookieManager(new CookieManager());
webClient.getCookieManager().addCookie(
new com.gargoylesoftware.htmlunit.util.Cookie(loginCookie.getDomain(),
loginCookie.getName(),
loginCookie.getValue()));
int mid = messagesService.createMessage(ugnich.getUid(), "new test", null, null);
subscriptionService.subscribeMessage(messagesService.getMessage(mid), freefd);
int rid = messagesService.createReply(mid, 0, ugnich, "new reply", null);
HtmlPage discussionsPage = webClient.getPage("http://localhost:8080/?show=discuss");
assertThat(discussionsPage.querySelectorAll("#global a .badge").size(), is(1));
HtmlPage unreadThread = webClient.getPage(String.format("http://localhost:8080/ugnich/%d", mid));
assertThat(unreadThread.querySelectorAll("#global a .badge").size(), is(0));
}
@Test
public void escapeSqlTests() {
String sql = String.format("SELECT * FROM table WHERE data='%s'", Utils.encodeSphinx("';-- DROP TABLE table"));
assertThat(sql, is("SELECT * FROM table WHERE data='\\';-- DROP TABLE table\'"));
}
@Test
public void swaggerOutput() throws Exception {
MvcResult result = mockMvc.perform(get("/v2/api-docs")
.accept(MediaType.APPLICATION_JSON_UTF8))
.andExpect(status().isOk())
.andReturn();
String outputDir = System.getProperty("io.springfox.staticdocs.outputDir");
Files.createDirectories(Paths.get(outputDir));
BufferedWriter writer = Files.newBufferedWriter(Paths.get(outputDir, "swagger.json"), StandardCharsets.UTF_8);
writer.write(result.getResponse().getContentAsString());
writer.flush();
}
@Test
public void newMessageShouldNotContainDuplicatedTags() throws Exception {
CommandResult result = commandsManager.processCommand(ugnich, "*test1 *test2 *test1 test3", emptyUri);
assertThat(result.getNewMessage().isPresent(), is(true));
Message msg = result.getNewMessage().get();
assertThat(msg.getTags().size(), is (2));
assertThat(msg.getTags().get(0).getName(), is("test1"));
assertThat(msg.getTags().get(1).getName(), is("test2"));
assertThat(msg.getText(), is("test3"));
}
@Test
public void oneClickUnsubscribe() throws Exception {
mockMvc.perform(post("/settings/unsubscribe")
.param("hash", "123456")
.param("List-Unsubscribe", "One-Click")).andExpect(status().isBadRequest());
mockMvc.perform(post("/settings/unsubscribe")
.param("hash", userService.getHashByUID(ugnich.getUid()))
.param("List-Unsubscribe", "One-Click")).andExpect(status().isOk());
}
}