Skip to content

Commit

Permalink
JAMES-1978 Make Subscription tests more generic
Browse files Browse the repository at this point in the history 
With many thanks to:

    Nguyen Thi Mai and Le Thi Huong Lai for their work on Quotas and In memory subscriptions
    Tran Thi & My Linh for their work on TooMuchLines
    txc1996 & Van Thanh For improving readability of SMTPAuthIsSuccessfulTest
    thienan090196 & Tran Thi & My Linh for their tests on RecipientIsLocalTest

From Passerelle Numeriques VietNam
  • Loading branch information
@chibenwa
chibenwa committed Mar 29, 2017
1 parent f1ea122 commit 4b11646
Show file tree
Hide file tree
Showing 3 changed files with 144 additions and 249 deletions.
158 changes: 10 additions & 148 deletions ...rc/test/java/org/apache/james/mailbox/cassandra/user/CassandraSubscriptionMapperTest.java
View file
Expand Up @@ -18,162 +18,24 @@
****************************************************************/
package org.apache.james.mailbox.cassandra.user;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.james.backends.cassandra.CassandraCluster;
import org.apache.james.mailbox.cassandra.modules.CassandraSubscriptionModule;
import org.apache.james.mailbox.store.user.model.Subscription;
import org.apache.james.mailbox.store.user.model.impl.SimpleSubscription;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.datastax.driver.core.Session;
import org.apache.james.mailbox.store.user.SubscriptionMapper;
import org.apache.james.mailbox.store.user.SubscriptionMapperTest;
import org.junit.After;

/**
* Runs tests for SubscriptionMapper.
*
*/
public class CassandraSubscriptionMapperTest {
public class CassandraSubscriptionMapperTest extends SubscriptionMapperTest {

private static final Logger LOG = LoggerFactory.getLogger(CassandraSubscriptionMapperTest.class);
private static final CassandraCluster CLUSTER = CassandraCluster.create(new CassandraSubscriptionModule());
private static Session session;
private static CassandraSubscriptionMapper mapper;
private static Map<String, List<SimpleSubscription>> subscriptionList;
private static final int USERS = 5;
private static final int MAILBOX_NO = 5;

@Before
public void setUp() throws Exception {
@Override
protected SubscriptionMapper createSubscriptionMapper() {
CLUSTER.ensureAllTables();
CLUSTER.clearAllTables();
session = CLUSTER.getConf();
mapper = new CassandraSubscriptionMapper(session);
fillSubscriptionList();
}

private static void fillSubscriptionList() {
LOG.info("Creating subscription list");
SimpleSubscription subscription;
String user, mailbox;
subscriptionList = new HashMap<>();
for (int i = 0; i < USERS; i++) {
user = "user" + i;
final List<SimpleSubscription> mailboxes = new ArrayList<>();
subscriptionList.put(user, mailboxes);

for (int j = 0; j < MAILBOX_NO; j++) {
if (j == 0) {
mailbox = "INBOX";
} else {
mailbox = "BOX" + j;
}
if ((i % 2 == 0) && (j > 0)) {
continue;
}
subscription = new SimpleSubscription(user, mailbox);
mailboxes.add(subscription);
mapper.save(subscription);
LOG.info("Adding subscription " + subscription);
}
}
}

/**
* Test of findMailboxSubscriptionForUser method, of class
* CassandraSubscriptionMapper.
*/
@Test
public void testFindMailboxSubscriptionForUser() throws Exception {
LOG.info("findMailboxSubscriptionForUser");

final SimpleSubscription fake1 = new SimpleSubscription("user1", "FAKEBOX");
final SimpleSubscription fake2 = new SimpleSubscription("fakeUser", "INBOX");

for (String user : subscriptionList.keySet()) {
LOG.info("Searching for all subscriptions for user:{}", user);
for (SimpleSubscription subscription : subscriptionList.get(user)) {
final Subscription result = mapper.findMailboxSubscriptionForUser(user, subscription.getMailbox());
assertEquals(subscription.getMailbox(), result.getMailbox());
assertEquals(subscription.getUser(), result.getUser());
}
}
assertNull(mapper.findMailboxSubscriptionForUser(fake1.getUser(), fake1.getMailbox()));
assertNull(mapper.findMailboxSubscriptionForUser(fake2.getUser(), fake2.getMailbox()));
}

/**
* Test of save method, of class CassandraSubscriptionMapper.
*/
@Test
public void testSave() throws Exception {
LOG.info("save");
final List<SimpleSubscription> subscriptions = mapper.list();
for (String user : subscriptionList.keySet()) {
for (Subscription subscription : subscriptionList.get(user)) {
assertTrue(containSubscription(subscriptions, subscription));
}
}
}

/**
* Test of findSubscriptionsForUser method, of class
* CassandraSubscriptionMapper.
*/
@Test
public void testFindSubscriptionsForUser() throws Exception {
LOG.info("findSubscriptionsForUser");
final SimpleSubscription fake2 = new SimpleSubscription("fakeUser", "INBOX");
for (String user : subscriptionList.keySet()) {
LOG.info("Searching for all subscriptions for user: " + user);
final List<Subscription> found = mapper.findSubscriptionsForUser(user);
assertEquals(subscriptionList.get(user).size(), found.size());
// TODO: patch Subscription to implement equals
// assertTrue(subscriptionList.get(user).containsAll(foundSubscriptions));
// assertTrue(foundSubscriptions.containsAll(subscriptionList.get(user)));
// assertFalse(foundSubscriptions.contains(fake1));
// assertFalse(foundSubscriptions.contains(fake2));
}
// TODO: check what value we should return in case of no subscriptions:
// null or empty list
assertEquals(mapper.findSubscriptionsForUser(fake2.getMailbox()).size(), 0);

}

/**
* Test of delete method, of class CassandraSubscriptionMapper.
*/
@Test
public void testDelete() throws Exception {
LOG.info("delete");
for (String user : subscriptionList.keySet()) {
LOG.info("Deleting subscriptions for user: " + user);
for (SimpleSubscription subscription : subscriptionList.get(user)) {
LOG.info("Deleting subscription : " + subscription);
mapper.delete(subscription);
assertFalse(containSubscription(mapper.list(), subscription));
}
}
fillSubscriptionList();
return new CassandraSubscriptionMapper(CLUSTER.getConf());
}

private boolean containSubscription(List<SimpleSubscription> subscriptions, Subscription subscription) {
for (SimpleSubscription s : subscriptions) {
if (subscription.getMailbox().equals(s.getMailbox()) && subscription.getUser().equals(s.getUser())) {
return true;
}
}
return false;
@After
public void tearDown() {
CLUSTER.clearAllTables();
}

}
107 changes: 6 additions & 101 deletions .../src/test/java/org/apache/james/mailbox/inmemory/user/InMemorySubscriptionMapperTest.java
View file
Expand Up @@ -19,108 +19,13 @@

package org.apache.james.mailbox.inmemory.user;

import static org.assertj.core.api.Assertions.assertThat;
import org.apache.james.mailbox.store.user.SubscriptionMapper;
import org.apache.james.mailbox.store.user.SubscriptionMapperTest;

import java.util.List;
public class InMemorySubscriptionMapperTest extends SubscriptionMapperTest {

import org.apache.james.mailbox.store.user.model.Subscription;
import org.apache.james.mailbox.store.user.model.impl.SimpleSubscription;
import org.junit.Before;
import org.junit.Test;

public class InMemorySubscriptionMapperTest {

private static final String USER_1 = "user1";
private static final String USER_2 = "user2";
private static final String MAILBOX_1 = "mailbox1";
private static final String MAILBOX_2 = "mailbox2";

private InMemorySubscriptionMapper testee;

@Before
public void setUp() {
testee = new InMemorySubscriptionMapper();
}

@Test
public void findSubscriptionsForUserShouldBeEmptyByDefault() {
List<Subscription> subscriptions = testee.findSubscriptionsForUser(USER_1);

assertThat(subscriptions).isEmpty();
}

@Test
public void findMailboxSubscriptionForUserShouldReturnNullByDefault() {
Subscription subscriptions = testee.findMailboxSubscriptionForUser(USER_1,MAILBOX_1);

assertThat(subscriptions).isNull();
}

@Test
public void findMailboxSubscriptionForUserShouldReturnSubscription() {
SimpleSubscription subscription = new SimpleSubscription(USER_1, MAILBOX_1);
testee.save(subscription);

List<Subscription> results = testee.findSubscriptionsForUser(USER_1);

assertThat(results).containsOnly(subscription);
}

@Test
public void findSubscriptionsForUserShouldReturnSubscriptions() {
SimpleSubscription subscription1 = new SimpleSubscription(USER_1, MAILBOX_1);
SimpleSubscription subscription2 = new SimpleSubscription(USER_1, MAILBOX_2);
testee.save(subscription1);
testee.save(subscription2);

List<Subscription> results = testee.findSubscriptionsForUser(USER_1);

assertThat(results).containsOnly(subscription1, subscription2);
}

@Test
public void findSubscriptionsForUserShouldReturnOnlyUserSubscriptions() {
SimpleSubscription subscription1 = new SimpleSubscription(USER_1,MAILBOX_1);
SimpleSubscription subscription2 = new SimpleSubscription(USER_2,MAILBOX_2);
testee.save(subscription1);
testee.save(subscription2);

List<Subscription> results = testee.findSubscriptionsForUser(USER_1);

assertThat(results).containsOnly(subscription1);
}

@Test
public void findMailboxSubscriptionForUserShouldReturnOnlyUserSubscriptions() {
SimpleSubscription subscription1 = new SimpleSubscription(USER_1,MAILBOX_1);
SimpleSubscription subscription2 = new SimpleSubscription(USER_2,MAILBOX_1);
testee.save(subscription1);
testee.save(subscription2);

Subscription result = testee.findMailboxSubscriptionForUser(USER_1,MAILBOX_1);

assertThat(result).isEqualTo(result);
}

@Test
public void findMailboxSubscriptionForUserShouldReturnSubscriptionConcerningTheMailbox() {
SimpleSubscription subscription1 = new SimpleSubscription(USER_1,MAILBOX_1);
SimpleSubscription subscription2 = new SimpleSubscription(USER_1,MAILBOX_2);
testee.save(subscription1);
testee.save(subscription2);

Subscription result = testee.findMailboxSubscriptionForUser(USER_1,MAILBOX_1);

assertThat(result).isEqualTo(result);
}

@Test
public void deleteShouldRemoveSubscription() {
SimpleSubscription subscription = new SimpleSubscription(USER_1, MAILBOX_1);
testee.save(subscription);

testee.delete(subscription);

assertThat(testee.findSubscriptionsForUser(USER_1)).isEmpty();
@Override
protected SubscriptionMapper createSubscriptionMapper() {
return new InMemorySubscriptionMapper();
}
}

0 comments on commit 4b11646

Please sign in to comment.