1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
|
package com.juick.xmpp.server;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.juick.Tag;
import com.juick.User;
import com.juick.components.JuickBot;
import com.juick.components.XMPPServer;
import com.juick.components.configuration.XmppAppConfiguration;
import com.juick.configuration.RepositoryConfiguration;
import com.juick.service.MessagesService;
import com.juick.service.SubscriptionService;
import com.juick.service.TagService;
import com.juick.service.UserService;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.TestPropertySource;
import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import org.springframework.test.context.web.WebAppConfiguration;
import org.springframework.test.web.servlet.MockMvc;
import org.springframework.test.web.servlet.setup.MockMvcBuilders;
import org.springframework.web.context.WebApplicationContext;
import rocks.xmpp.addr.Jid;
import rocks.xmpp.core.stanza.model.Stanza;
import rocks.xmpp.core.stanza.model.server.ServerMessage;
import javax.inject.Inject;
import java.lang.reflect.InvocationTargetException;
import java.text.ParseException;
import java.util.Collections;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.equalTo;
import static org.hamcrest.Matchers.is;
import static org.junit.Assert.assertEquals;
import static org.springframework.test.web.servlet.request.MockMvcRequestBuilders.get;
import static org.springframework.test.web.servlet.result.MockMvcResultMatchers.status;
@RunWith(SpringJUnit4ClassRunner.class)
@WebAppConfiguration
@ContextConfiguration(classes = {
XmppAppConfiguration.class, RepositoryConfiguration.class
})
@TestPropertySource(properties = {"broken_ssl_hosts=localhost,serverstorageisfull.tld"})
public class XMPPServerTests extends AbstractJUnit4SpringContextTests {
@Inject
private WebApplicationContext wac;
@Inject
private XMPPServer server;
@Inject
private JuickBot bot;
@Inject
private UserService userService;
@Inject
private MessagesService messagesService;
@Inject
private TagService tagService;
@Inject
private SubscriptionService subscriptionService;
@Inject
private JdbcTemplate jdbcTemplate;
@Value("${hostname}")
private Jid jid;
private MockMvc mockMvc;
@Before
public void setup() {
mockMvc = MockMvcBuilders.webAppContextSetup(this.wac).build();
}
@Test
public void statusPageIsUp() throws Exception {
mockMvc.perform(get("http://localhost:8080/status")).andExpect(status().isOk());
assertThat(server.getJid(), equalTo(jid));
}
@Test
public void botIsUpAndProcessingResourceConstraints() {
int renhaId;
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);
String xmlMessage = "<message xmlns=\"jabber:server\" from=\"renha@serverstorageisfull.tld\" to=\"juick@juick.com/Juick\" type=\"error\"><body>Reply by @LexX</body><juick xmlns=\"http://juick.com/message\" mid=\"2885759\" privacy=\"1\" replyto=\"0\" rid=\"8\" ts=\"2017-10-10 07:41:10\"><body>Похоже нынче можно публично заявлять о своем веганстве. </body><user xmlns=\"http://juick.com/user\" uname=\"LexX\" uid=\"6340\"></user></juick><error type=\"wait\"><resource-constraint xmlns=\"urn:ietf:params:xml:ns:xmpp-stanzas\"></resource-constraint><text xmlns=\"urn:ietf:params:xml:ns:xmpp-stanzas\">Your contact offline message queue is full. The message has been discarded.</text></error></message>";
Stanza msg = server.parse(xmlMessage);
assertThat(from, equalTo(msg.getFrom()));
boolean isActive = jdbcTemplate.queryForObject("SELECT active FROM jids WHERE user_id=?", Integer.class, renhaId) == 1;
assertThat(isActive, equalTo(true));
bot.incomingMessage((ServerMessage)msg);
isActive = jdbcTemplate.queryForObject("SELECT active FROM jids WHERE user_id=?", Integer.class, renhaId) == 1;
assertThat(isActive, equalTo(false));
}
@Test
public void botCommandsTests() throws IllegalAccessException, NoSuchMethodException, InvocationTargetException {
assertThat(bot.processCommand(new User(), Jid.of("test@localhost"), "PING").get(), is("PONG"));
// tag help have two lines, others have 1
assertThat(bot.processCommand(new User(), Jid.of("test@localhost"), "help").get().split("\n").length, is(18));
}
@Test
public void protocolTests() throws IllegalAccessException, NoSuchMethodException, InvocationTargetException, ParseException, JsonProcessingException {
int uid = userService.createUser("me", "secret");
User user = userService.getUserByUID(uid).orElse(new User());
Tag yo = tagService.getTag("yo", true);
int mid = messagesService.createMessage(uid, "yoyo", null, Collections.singletonList(yo));
assertEquals("should be message", true,
bot.processCommand(user, Jid.of("test@localhost"), String.format("#%d", mid)).get().startsWith("@me"));
mid = messagesService.getUserBlog(user.getUid(), -1, 0).stream().reduce((first, second) -> second).get();
assertEquals("text should match", "yoyo",
messagesService.getMessage(mid).getText());
assertEquals("tag should match", "yo",
tagService.getMessageTags(mid).get(0).getTag().getName());
int readerUid = userService.createUser("dummyReader", "dummySecret");
User readerUser = userService.getUserByUID(readerUid).orElse(new User());
assertEquals("should be subscribed", "Subscribed",
bot.processCommand(readerUser, Jid.of("dummy@localhost"), "S #" + mid).get());
/* TODO: move from juick-legacy
assertEquals("should be favorited", "Message added to your recommendations",
juickProtocol.getReply(readerUser, "! #" + mid));
*/
assertEquals("number of subscribed users should match", 1,
subscriptionService.getUsersSubscribedToComments(mid, uid).size());
/*
assertEquals("should be subscribed", "Subscribed",
bot.processCommand(readerUser, Jid.of("dummy@localhost"), "S @" + user.getName()).get());
List<User> 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 expectedReply = "Reply posted.\n#" + mid + "/1 "
+ "http://juick.com/" + mid + "#1";
String expectedSecondReply = "Reply posted.\n#" + mid + "/2 "
+ "http://juick.com/" + mid + "#2";
assertEquals("should be reply", expectedReply,
bot.processCommand(user, Jid.of("test@localhost"), "#" + mid + " yoyo").get());
assertEquals("should be second reply", expectedSecondReply,
bot.processCommand(user, Jid.of("test@localhost"), "#" + mid + "/1 yoyo").get());
Message reply = messagesService.getReplies(mid).stream().filter(m -> m.getRid() == 2).findFirst()
.orElse(new Message());
assertEquals("should be reply to first comment", 1, reply.getReplyto());
assertNotEquals("tags should NOT be updated", "Tags are updated",
bot.processCommand(readerUser, Jid.of("dummy@localhost"), "#" + mid + " *yo *there").get());
assertEquals("tags should be updated", "Tags are updated",
bot.processCommand(user, Jid.of("test@localhost"), "#" + mid + " *there").get());
assertEquals("number of tags should match", 2,
tagService.getMessageTags(mid).size());
assertEquals("should be blacklisted", "Tag added to your blacklist",
bot.processCommand(readerUser, Jid.of("dummy@localhost"), "BL *there").get());
assertEquals("number of subscribed users should match", 0,
subscriptionService.getSubscribedUsers(uid, mid).size());
assertEquals("tags should be updated", "Tags are updated",
bot.processCommand(user, Jid.of("test@localhost"), "#" + mid + " *there").get());
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",
bot.processCommand(taggerUser, Jid.of("tagger@localhost"), "S *yo").get());
assertEquals("number of subscribed users should match", 2,
subscriptionService.getSubscribedUsers(uid, mid).size());
assertEquals("should be unsubscribed", "Unsubscribed from yo",
bot.processCommand(taggerUser, Jid.of("tagger@localhost"), "U *yo").get());
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 = bot.processCommand(readerUser, Jid.of("dummy@localhost"), "#").get();
assertEquals("description should match", true, readerFeed.startsWith("Your feed"));
assertEquals("should be unsubscribed", "Unsubscribed from @" + user.getName(),
bot.processCommand(readerUser, Jid.of("dummy@localhost"), "U @" + user.getName()).get());
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,
bot.processCommand(readerUser, Jid.of("dummy@localhost"), "u #" + mid).get());
assertEquals("number of subscribed users should match", 0,
subscriptionService.getUsersSubscribedToComments(mid, uid).size());
assertNotEquals("should NOT be deleted", String.format("Message %s deleted", mid),
bot.processCommand(readerUser, Jid.of("dummy@localhost"), "D #" + mid).get());
assertEquals("should be deleted", String.format("Message %s deleted", mid),
bot.processCommand(user, Jid.of("test@localhost"), "D #" + mid).get());
assertEquals("should not have messages", 0, messagesService.getAll(user.getUid(), 0).size());
*/
}
}
|
