@Test
public void findPrimaryConnection_afterRemove() {
insertFacebookConnection();
insertFacebookConnection2();
// 9 is the providerUserId of the first Facebook connection
connectionRepository.removeConnection(new ConnectionKey("facebook", "9"));
assertEquals(1, connectionRepository.findConnections(TestFacebookApi.class).size());
assertNotNull(connectionRepository.findPrimaryConnection(TestFacebookApi.class));
}
@Test
public void addConnection() {
Connection<TestFacebookApi> connection =
connectionFactory.createConnection(new AccessGrant("123456789", null, "987654321", 3600L));
connectionRepository.addConnection(connection);
Connection<TestFacebookApi> restoredConnection =
connectionRepository.getPrimaryConnection(TestFacebookApi.class);
assertEquals(connection, restoredConnection);
assertNewConnection(restoredConnection);
}
@Test
public void findConnectionByApiToUser() {
insertFacebookConnection();
insertFacebookConnection2();
assertFacebookConnection(connectionRepository.getConnection(TestFacebookApi.class, "9"));
assertEquals(
"10",
connectionRepository
.getConnection(TestFacebookApi.class, "10")
.getKey()
.getProviderUserId());
}
/**
* Creates a new Connection object. Expects <> won:hasFacet [FACET] in the RDF content, will throw
* exception if it's not there.
*
* @param needURI
* @param otherNeedURI
* @param otherConnectionURI
* @param content
* @param connectionState
* @param connectionEventType
* @return
* @throws NoSuchNeedException
* @throws IllegalMessageForNeedStateException
* @throws ConnectionAlreadyExistsException
*/
public Connection createConnection(
final URI needURI,
final URI otherNeedURI,
final URI otherConnectionURI,
final Model content,
final ConnectionState connectionState,
final ConnectionEventType connectionEventType)
throws NoSuchNeedException, IllegalMessageForNeedStateException,
ConnectionAlreadyExistsException {
if (needURI == null) throw new IllegalArgumentException("needURI is not set");
if (otherNeedURI == null) throw new IllegalArgumentException("otherNeedURI is not set");
if (needURI.equals(otherNeedURI))
throw new IllegalArgumentException("needURI and otherNeedURI are the same");
// Load need (throws exception if not found)
Need need = DataAccessUtils.loadNeed(needRepository, needURI);
if (!isNeedActive(need))
throw new IllegalMessageForNeedStateException(
needURI, connectionEventType.name(), need.getState());
URI facetURI = getFacet(content);
if (facetURI == null)
throw new IllegalArgumentException(
"at least one RDF node must be of type won:" + WON.HAS_FACET.getLocalName());
// TODO: create a proper exception if a facet is not supported by a need
if (facetRepository.findByNeedURIAndTypeURI(needURI, facetURI).isEmpty())
throw new RuntimeException("Facet is not supported by Need: " + facetURI);
List<Connection> connections =
connectionRepository.findByNeedURIAndRemoteNeedURI(needURI, otherNeedURI);
Connection con = getConnection(connections, facetURI, connectionEventType);
if (con == null) {
/* Create connection */
con = new Connection();
con.setNeedURI(needURI);
con.setState(connectionState);
con.setRemoteNeedURI(otherNeedURI);
con.setRemoteConnectionURI(otherConnectionURI);
con.setTypeURI(facetURI);
// save connection (this creates a new id)
con = connectionRepository.saveAndFlush(con);
// create and set new uri
con.setConnectionURI(URIService.createConnectionURI(con));
con = connectionRepository.saveAndFlush(con);
// TODO: do we save the connection content? where? as a chat content?
}
return con;
}
@Test
public void updateConnectionProfileFields() {
connectionFactoryRegistry.addConnectionFactory(new TestTwitterConnectionFactory());
insertTwitterConnection();
Connection<TestTwitterApi> twitter =
connectionRepository.getPrimaryConnection(TestTwitterApi.class);
assertEquals("http://twitter.com/kdonald/picture", twitter.getImageUrl());
twitter.sync();
assertEquals("http://twitter.com/kdonald/a_new_picture", twitter.getImageUrl());
connectionRepository.updateConnection(twitter);
Connection<TestTwitterApi> twitter2 =
connectionRepository.getPrimaryConnection(TestTwitterApi.class);
assertEquals("http://twitter.com/kdonald/a_new_picture", twitter2.getImageUrl());
}
@Test
public void updateConnectionAccessFields() {
insertFacebookConnection();
Connection<TestFacebookApi> facebook =
connectionRepository.getPrimaryConnection(TestFacebookApi.class);
assertEquals("234567890", facebook.getApi().getAccessToken());
facebook.refresh();
connectionRepository.updateConnection(facebook);
Connection<TestFacebookApi> facebook2 =
connectionRepository.getPrimaryConnection(TestFacebookApi.class);
assertEquals("765432109", facebook2.getApi().getAccessToken());
ConnectionData data = facebook.createData();
assertEquals("654321098", data.getRefreshToken());
}
@Test(expected = DataIntegrityViolationException.class)
public void addConnectionDuplicate() {
Connection<TestFacebookApi> connection =
connectionFactory.createConnection(new AccessGrant("123456789", null, "987654321", 3600L));
connectionRepository.addConnection(connection);
connectionRepository.addConnection(connection);
}
@Test
public void removeConnection() {
SocialUserConnection facebookConnection = insertFacebookConnection();
assertThat(socialUserConnectionRepository.findOne(facebookConnection.getId())).isNotNull();
connectionRepository.removeConnection(new ConnectionKey("facebook", "9"));
assertThat(socialUserConnectionRepository.findOne(facebookConnection.getId())).isNull();
}
@Test
@SuppressWarnings("unchecked")
public void findConnectionByKey() {
insertFacebookConnection();
assertFacebookConnection(
(Connection<TestFacebookApi>)
connectionRepository.getConnection(new ConnectionKey("facebook", "9")));
}
@Test
public void findAllConnectionsEmptyResult() {
connectionFactoryRegistry.addConnectionFactory(new TestTwitterConnectionFactory());
MultiValueMap<String, Connection<?>> connections = connectionRepository.findAllConnections();
assertEquals(2, connections.size());
assertEquals(0, connections.get("facebook").size());
assertEquals(0, connections.get("twitter").size());
}
@Test
public void findUserIdWithConnection() {
insertFacebookConnection();
List<String> userIds =
usersConnectionRepository.findUserIdsWithConnection(
connectionRepository.getPrimaryConnection(TestFacebookApi.class));
assertEquals("1", userIds.get(0));
}
@Test
public void findConnectionsByApi() {
insertFacebookConnection();
insertFacebookConnection2();
List<Connection<TestFacebookApi>> connections =
connectionRepository.findConnections(TestFacebookApi.class);
assertEquals(2, connections.size());
assertFacebookConnection(connections.get(0));
}
@Test
@SuppressWarnings("unchecked")
public void findConnectionsByProviderId() {
connectionFactoryRegistry.addConnectionFactory(new TestTwitterConnectionFactory());
insertTwitterConnection();
List<Connection<?>> connections = connectionRepository.findConnections("twitter");
assertEquals(1, connections.size());
assertTwitterConnection((Connection<TestTwitterApi>) connections.get(0));
}
public List<User> getConnectionsNotInGroupByGroupIdAndEmail(int groupId, String email) {
List<User> connectionGroupUsers =
connectionGroupUserRepository.getUsersInConnectionGroup(groupId);
List<User> connections = connectionRepository.getConnectionsByEmail(email);
return connections
.stream()
.filter(user -> !connectionGroupUsers.contains(user))
.collect(Collectors.toList());
}
public List<User> getConnectionsNotInvitedToChat(String email, int chatId) {
List<User> connections = connectionRepository.getConnectionsByEmail(email);
List<User> chatUsers = chatUserRepository.getChatUsersInGroup(chatId);
return connections
.stream()
.filter(user -> !chatUsers.contains(user))
.collect(Collectors.toList());
}
@Test
public void findUserIdWithConnectionMultipleConnectionsToSameProviderUser() {
insertFacebookConnection();
insertFacebookConnectionSameFacebookUser();
List<String> localUserIds =
usersConnectionRepository.findUserIdsWithConnection(
connectionRepository.getPrimaryConnection(TestFacebookApi.class));
assertEquals(2, localUserIds.size());
assertEquals("1", localUserIds.get(0));
assertEquals("2", localUserIds.get(1));
}
public Connection nextConnectionState(URI connectionURI, ConnectionEventType connectionEventType)
throws NoSuchConnectionException, IllegalMessageForConnectionStateException {
if (connectionURI == null) throw new IllegalArgumentException("connectionURI is not set");
// load connection, checking if it exists
Connection con = DataAccessUtils.loadConnection(connectionRepository, connectionURI);
// perform state transit
ConnectionState nextState = performStateTransit(con, connectionEventType);
// set new state and save in the db
con.setState(nextState);
// save in the db
return connectionRepository.saveAndFlush(con);
}
public List<User> getConnectionsNotInvited(String email, Integer eventId) {
List<User> list = connectionRepository.getConnectionsByEmail(email);
Event event = eventRepository.findOne(eventId);
for (EventInvite invite : event.getEventInvites()) {
if (list.contains(invite.getUserInvited())) {
list.remove(invite.getUserInvited());
}
}
if (list.contains(event.getCreator())) {
list.remove(event.getCreator());
}
return list;
}
@Test
@SuppressWarnings("unchecked")
public void findAllConnections() {
connectionFactoryRegistry.addConnectionFactory(new TestTwitterConnectionFactory());
insertTwitterConnection();
insertFacebookConnection();
MultiValueMap<String, Connection<?>> connections = connectionRepository.findAllConnections();
assertEquals(2, connections.size());
Connection<TestFacebookApi> facebook =
(Connection<TestFacebookApi>) connections.getFirst("facebook");
assertFacebookConnection(facebook);
Connection<TestTwitterApi> twitter =
(Connection<TestTwitterApi>) connections.getFirst("twitter");
assertTwitterConnection(twitter);
}
@Test
@SuppressWarnings("unchecked")
public void findConnectionsToUsers() {
connectionFactoryRegistry.addConnectionFactory(new TestTwitterConnectionFactory());
insertTwitterConnection();
insertFacebookConnection();
insertFacebookConnection2();
MultiValueMap<String, String> providerUsers = new LinkedMultiValueMap<>();
providerUsers.add("facebook", "10");
providerUsers.add("facebook", "9");
providerUsers.add("twitter", "1");
MultiValueMap<String, Connection<?>> connectionsForUsers =
connectionRepository.findConnectionsToUsers(providerUsers);
assertEquals(2, connectionsForUsers.size());
assertEquals("10", connectionsForUsers.getFirst("facebook").getKey().getProviderUserId());
assertFacebookConnection(
(Connection<TestFacebookApi>) connectionsForUsers.get("facebook").get(1));
assertTwitterConnection((Connection<TestTwitterApi>) connectionsForUsers.getFirst("twitter"));
}
public Connection getConnection(
List<Connection> connections, URI facetURI, ConnectionEventType eventType)
throws ConnectionAlreadyExistsException {
Connection con = null;
for (Connection c : connections) {
// TODO: check remote need type as well or create GroupMemberFacet
if (facetURI.equals(c.getTypeURI())) con = c;
}
/**
* check if there already exists a connection between those two we have multiple options: a) no
* connection exists -> create new b) a connection exists in state CONNECTED -> error message c)
* a connection exists in state REQUEST_SENT. The call must be a duplicate (or re-sent after the
* remote end hasn't replied for some time) -> error message d) a connection exists in state
* REQUEST_RECEIVED. The remote end tried to connect before we did. -> error message e) a
* connection exists in state CLOSED -> create new
*/
// TODO: impose unique constraint on connections
if (con != null) {
if (con.getState() == ConnectionState.CONNECTED
|| con.getState() == ConnectionState.REQUEST_SENT)
throw new ConnectionAlreadyExistsException(
con.getConnectionURI(), con.getNeedURI(), con.getRemoteNeedURI());
/*if(!eventType.isMessageAllowed(con.getState())){
throw new ConnectionAlreadyExistsException(con.getConnectionURI(), con.getNeedURI(), con.getRemoteNeedURI());
}*/ else {
// TODO: Move this to the transition() - Method in ConnectionState
con.setState(con.getState().transit(eventType));
con = connectionRepository.saveAndFlush(con);
}
}
return con;
}
@Test(expected = NotConnectedException.class)
public void findPrimaryConnectionNotConnected() {
connectionRepository.getPrimaryConnection(TestFacebookApi.class);
}
public void updateRemoteConnectionURI(Connection con, URI remoteConnectionURI) {
con.setRemoteConnectionURI(remoteConnectionURI);
connectionRepository.saveAndFlush(con);
}
@Test(expected = IllegalArgumentException.class)
public void findConnectionsToUsersEmptyInput() {
MultiValueMap<String, String> providerUsers = new LinkedMultiValueMap<>();
connectionRepository.findConnectionsToUsers(providerUsers);
}
@Test(expected = NoSuchConnectionException.class)
public void findConnectionByKeyNoSuchConnection() {
connectionRepository.getConnection(new ConnectionKey("facebook", "bogus"));
}
@Test(expected = NoSuchConnectionException.class)
public void findConnectionByApiToUserNoSuchConnection() {
assertFacebookConnection(connectionRepository.getConnection(TestFacebookApi.class, "9"));
}
@Test
public void removeConnectionNoOp() {
connectionRepository.removeConnection(new ConnectionKey("facebook", "1"));
}
@Test
public void findPrimaryConnection() {
insertFacebookConnection();
assertFacebookConnection(connectionRepository.getPrimaryConnection(TestFacebookApi.class));
}
@Test
public void removeConnectionsToProviderNoOp() {
connectionRepository.removeConnections("twitter");
}
@Test
public void findPrimaryConnectionSelectFromMultipleByRank() {
insertFacebookConnection2();
insertFacebookConnection();
assertFacebookConnection(connectionRepository.getPrimaryConnection(TestFacebookApi.class));
}
