Author: matthieu
Date: Mon Nov 2 13:47:42 2015
New Revision: 1711988
URL: http://svn.apache.org/viewvc?rev=1711988&view=rev
Log:
JAMES-1595 Migrate AbstractRecipientRewriteTableTest to assertj
Modified:
james/project/trunk/server/data/data-library/src/test/java/org/apache/james/rrt/lib/AbstractRecipientRewriteTableTest.java
Modified:
james/project/trunk/server/data/data-library/src/test/java/org/apache/james/rrt/lib/AbstractRecipientRewriteTableTest.java
URL:
http://svn.apache.org/viewvc/james/project/trunk/server/data/data-library/src/test/java/org/apache/james/rrt/lib/AbstractRecipientRewriteTableTest.java?rev=1711988&r1=1711987&r2=1711988&view=diff
==============================================================================
---
james/project/trunk/server/data/data-library/src/test/java/org/apache/james/rrt/lib/AbstractRecipientRewriteTableTest.java
(original)
+++
james/project/trunk/server/data/data-library/src/test/java/org/apache/james/rrt/lib/AbstractRecipientRewriteTableTest.java
Mon Nov 2 13:47:42 2015
@@ -18,13 +18,10 @@
****************************************************************/
package org.apache.james.rrt.lib;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNull;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.fail;
import java.util.Arrays;
-import java.util.Iterator;
import java.util.Map;
import org.apache.james.lifecycle.api.LifecycleUtil;
@@ -94,27 +91,26 @@ public abstract class AbstractRecipientR
try {
- assertNull("No mapping", virtualUserTable.getMappings(user,
domain));
-
- assertTrue("Added virtual mapping", addMapping(user, domain,
regex, REGEX_TYPE));
- assertTrue("Added virtual mapping", addMapping(user, domain,
regex2, REGEX_TYPE));
- assertEquals("Two mappings", virtualUserTable.getMappings(user,
domain).size(), 2);
- assertEquals("One mappingline",
virtualUserTable.getAllMappings().size(), 1);
-
- assertTrue("remove virtual mapping", removeMapping(user, domain,
regex, REGEX_TYPE));
+ assertThat(virtualUserTable.getMappings(user,
domain)).describedAs("No mapping").isNull();
+ assertThat(addMapping(user, domain, regex,
REGEX_TYPE)).describedAs("Added virtual mapping").isTrue();
+ assertThat(addMapping(user, domain, regex2,
REGEX_TYPE)).describedAs("Added virtual mapping").isTrue();
+ assertThat(virtualUserTable.getMappings(user,
domain)).describedAs("Two mappings").hasSize(2);
+ assertThat(virtualUserTable.getAllMappings()).describedAs("One
mappingline").hasSize(1);
+ assertThat(removeMapping(user, domain, regex,
REGEX_TYPE)).describedAs("remove virtual mapping").isTrue();
+
try {
virtualUserTable.addRegexMapping(user, domain, invalidRegex);
} catch (RecipientRewriteTableException e) {
catched = true;
}
- assertTrue("Invalid Mapping throw exception", catched);
-
- assertTrue("remove virtual mapping", removeMapping(user, domain,
regex2, REGEX_TYPE));
-
- assertNull("No mapping", virtualUserTable.getMappings(user,
domain));
-
- assertNull("No mappings", virtualUserTable.getAllMappings());
+
+ assertThat(catched).describedAs("Invalid Mapping throw
exception").isTrue();
+ assertThat(removeMapping(user, domain, regex2,
REGEX_TYPE)).describedAs("remove virtual mapping").isTrue();
+
+
+ assertThat(virtualUserTable.getMappings(user,
domain)).describedAs("No mapping").isNull();
+ assertThat(virtualUserTable.getAllMappings()).describedAs("No
mapping").isNull();
} catch (IllegalArgumentException e) {
e.printStackTrace();
@@ -133,15 +129,15 @@ public abstract class AbstractRecipientR
try {
- assertNull("No mapping", virtualUserTable.getMappings(user,
domain));
+ assertThat(virtualUserTable.getMappings(user,
domain)).describedAs("No mapping").isNull();
- assertTrue("Added virtual mapping", addMapping(user, domain,
address, ADDRESS_TYPE));
- assertTrue("Added virtual mapping", addMapping(user, domain,
address2, ADDRESS_TYPE));
+ assertThat(addMapping(user, domain, address,
ADDRESS_TYPE)).describedAs("Added virtual mapping").isTrue();
+ assertThat(addMapping(user, domain, address2,
ADDRESS_TYPE)).describedAs("Added virtual mapping").isTrue();
- assertEquals("Two mappings", virtualUserTable.getMappings(user,
domain).size(), 2);
- assertEquals("One mappingline",
virtualUserTable.getAllMappings().size(), 1);
+ assertThat(virtualUserTable.getMappings(user,
domain)).describedAs("Two mappings").hasSize(2);
+ assertThat(virtualUserTable.getAllMappings()).describedAs("One
mappingline").hasSize(1);
- assertTrue("remove virtual mapping", removeMapping(user, domain,
address, ADDRESS_TYPE));
+ assertThat(removeMapping(user, domain, address,
ADDRESS_TYPE)).describedAs("remove virtual mapping").isTrue();
/*
* TEMPORARILY REMOVE JDBC specific test String invalidAddress=
@@ -153,10 +149,11 @@ public abstract class AbstractRecipientR
* assertTrue("Invalid Mapping throw exception" , catched); }
*/
- assertTrue("remove virtual mapping", removeMapping(user, domain,
address2, ADDRESS_TYPE));
+
+ assertThat(removeMapping(user, domain, address2,
ADDRESS_TYPE)).describedAs("remove virtual mapping").isTrue();
- assertNull("No mapping", virtualUserTable.getMappings(user,
domain));
- assertNull("No mappings", virtualUserTable.getAllMappings());
+ assertThat(virtualUserTable.getMappings(user,
domain)).describedAs("No mapping").isNull();
+ assertThat(virtualUserTable.getAllMappings()).describedAs("No
mapping").isNull();
} catch (IllegalArgumentException e) {
fail("Storing failed");
@@ -173,23 +170,22 @@ public abstract class AbstractRecipientR
boolean catched = false;
try {
+ assertThat(virtualUserTable.getMappings(user,
domain)).describedAs("No mapping").isNull();
- assertNull("No mapping", virtualUserTable.getMappings(user,
domain));
-
- assertTrue("Added virtual mapping", addMapping(user, domain,
error, ERROR_TYPE));
- assertEquals("One mappingline",
virtualUserTable.getAllMappings().size(), 1);
+ assertThat(addMapping(user, domain, error,
ERROR_TYPE)).describedAs("Added virtual mapping").isTrue();
+ assertThat(virtualUserTable.getAllMappings()).describedAs("One
mappingline").hasSize(1);
try {
virtualUserTable.getMappings(user, domain);
} catch (ErrorMappingException e) {
catched = true;
}
- assertTrue("Error Mapping throw exception", catched);
+ assertThat(catched).describedAs("Error Mapping throw
exception").isTrue();
- assertTrue("remove virtual mapping", removeMapping(user, domain,
error, ERROR_TYPE));
- assertNull("No mapping", virtualUserTable.getMappings(user,
domain));
- assertNull("No mappings", virtualUserTable.getAllMappings());
+ assertThat(removeMapping(user, domain, error,
ERROR_TYPE)).describedAs("remove virtual mapping").isTrue();
+ assertThat(virtualUserTable.getMappings(user,
domain)).describedAs("No mapping").isNull();
+ assertThat(virtualUserTable.getAllMappings()).describedAs("No
mapping").isNull();
} catch (IllegalArgumentException e) {
fail("Storing failed");
}
@@ -208,20 +204,19 @@ public abstract class AbstractRecipientR
try {
- assertNull("No mapping", virtualUserTable.getMappings(user,
domain));
+ assertThat(virtualUserTable.getMappings(user,
domain)).describedAs("No mapping").isNull();
- assertTrue("Added virtual mapping",
- addMapping(RecipientRewriteTable.WILDCARD, domain,
address, ADDRESS_TYPE));
- assertTrue("Added virtual mapping", addMapping(user, domain,
address2, ADDRESS_TYPE));
-
- assertEquals("One mappings", 1, virtualUserTable.getMappings(user,
domain).size());
- assertEquals("One mappings", 1,
virtualUserTable.getMappings(user2, domain).size());
-
- assertTrue("remove virtual mapping", removeMapping(user, domain,
address2, ADDRESS_TYPE));
- assertTrue("remove virtual mapping",
removeMapping(RecipientRewriteTable.WILDCARD, domain, address,
- ADDRESS_TYPE));
- assertNull("No mapping", virtualUserTable.getMappings(user,
domain));
- assertNull("No mapping", virtualUserTable.getMappings(user2,
domain));
+ assertThat(addMapping(RecipientRewriteTable.WILDCARD, domain,
address, ADDRESS_TYPE)).describedAs("Added virtual mapping").isTrue();
+ assertThat(addMapping(user, domain, address2,
ADDRESS_TYPE)).describedAs("Added virtual mapping").isTrue();
+
+ assertThat(virtualUserTable.getMappings(user,
domain)).describedAs("One mappings").hasSize(1);
+ assertThat(virtualUserTable.getMappings(user2,
domain)).describedAs("One mappings").hasSize(1);
+
+ assertThat(removeMapping(user, domain, address2,
ADDRESS_TYPE)).describedAs("remove virtual mapping").isTrue();
+ assertThat(removeMapping(RecipientRewriteTable.WILDCARD, domain,
address, ADDRESS_TYPE)).describedAs("remove virtual mapping").isTrue();
+
+ assertThat(virtualUserTable.getMappings(user,
domain)).describedAs("No mapping").isNull();
+ assertThat(virtualUserTable.getMappings(user2,
domain)).describedAs("No mapping").isNull();
} catch (IllegalArgumentException e) {
fail("Storing failed");
@@ -243,25 +238,23 @@ public abstract class AbstractRecipientR
virtualUserTable.setRecursiveMapping(true);
try {
- assertNull("No mappings", virtualUserTable.getAllMappings());
-
- assertTrue("Add mapping", addMapping(user1, domain1, user2 + "@" +
domain2, ADDRESS_TYPE));
- assertTrue("Add mapping", addMapping(user2, domain2, user3 + "@" +
domain3, ADDRESS_TYPE));
- assertEquals("Recursive mapped",
virtualUserTable.getMappings(user1, domain1).iterator().next(),
- MappingImpl.of(user3 + "@" + domain3));
+ assertThat(virtualUserTable.getAllMappings()).describedAs("No
mapping").isNull();
- assertTrue("Add mapping", addMapping(user3, domain3, user1 + "@" +
domain1, ADDRESS_TYPE));
+ assertThat(addMapping(user1, domain1, user2 + "@" + domain2,
ADDRESS_TYPE)).describedAs("Added mapping").isTrue();
+ assertThat(addMapping(user2, domain2, user3 + "@" + domain3,
ADDRESS_TYPE)).describedAs("Added mapping").isTrue();
+ assertThat(virtualUserTable.getMappings(user1,
domain1)).containsOnly(MappingImpl.of(user3 + "@" + domain3));
+ assertThat(addMapping(user3, domain3, user1 + "@" + domain1,
ADDRESS_TYPE)).describedAs("Added mapping").isTrue();
+
try {
virtualUserTable.getMappings(user1, domain1);
} catch (ErrorMappingException e) {
exception1 = true;
}
- assertTrue("Exception thrown on to many mappings", exception1);
+ assertThat(exception1).describedAs("Exception thrown on to many
mappings").isTrue();
// disable recursive mapping
virtualUserTable.setRecursiveMapping(false);
- assertEquals("Not recursive mapped",
virtualUserTable.getMappings(user1, domain1).iterator().next(),
- MappingImpl.of(user2 + "@" + domain2));
+ assertThat(virtualUserTable.getMappings(user1,
domain1)).describedAs("Not recursive
mapped").containsExactly(MappingImpl.of(user2 + "@" + domain2));
} catch (IllegalArgumentException e) {
fail("Storing failed");
@@ -276,23 +269,24 @@ public abstract class AbstractRecipientR
String user = "user";
String user2 = "user2";
- assertNull("No mappings", virtualUserTable.getAllMappings());
+ assertThat(virtualUserTable.getAllMappings()).describedAs("No
mappings").isNull();
try {
- assertTrue("Add mapping",
addMapping(RecipientRewriteTable.WILDCARD, aliasDomain, user2 + "@" + domain,
- ADDRESS_TYPE));
- assertTrue("Add aliasDomain mapping",
addMapping(RecipientRewriteTable.WILDCARD, aliasDomain, domain,
- ALIASDOMAIN_TYPE));
-
- Iterator<String> mappings = virtualUserTable.getMappings(user,
aliasDomain).asStrings().iterator();
- assertEquals("Domain mapped as first ", mappings.next(), user +
"@" + domain);
- assertEquals("Address mapped as second ", mappings.next(), user2 +
"@" + domain);
-
- assertTrue("Remove mapping",
removeMapping(RecipientRewriteTable.WILDCARD, aliasDomain, user2 + "@" + domain,
- ADDRESS_TYPE));
- assertTrue("Remove aliasDomain mapping",
removeMapping(RecipientRewriteTable.WILDCARD, aliasDomain, domain,
- ALIASDOMAIN_TYPE));
+ assertThat(addMapping(RecipientRewriteTable.WILDCARD, aliasDomain,
user2 + "@" + domain,
+ ADDRESS_TYPE)).describedAs("Add mapping").isTrue();
+ assertThat(addMapping(RecipientRewriteTable.WILDCARD, aliasDomain,
domain,
+ ALIASDOMAIN_TYPE)).describedAs("Add aliasDomain
mapping").isTrue();
+
+ assertThat(virtualUserTable.getMappings(user, aliasDomain))
+ .describedAs("Domain mapped as first, Address mapped as
second")
+ .containsExactly(MappingImpl.of(user + "@" + domain),
MappingImpl.of(user2 + "@" + domain));
+
+ assertThat(removeMapping(RecipientRewriteTable.WILDCARD,
aliasDomain, user2 + "@" + domain,
+ ADDRESS_TYPE)).describedAs("Remove mapping").isTrue();
+
+ assertThat(removeMapping(RecipientRewriteTable.WILDCARD,
aliasDomain, domain,
+ ALIASDOMAIN_TYPE)).describedAs("Remove aliasDomain
mapping").isTrue();
} catch (IllegalArgumentException e) {
fail("Storing failed");
@@ -302,18 +296,18 @@ public abstract class AbstractRecipientR
@Test
public void sortMappingsShouldReturnNullWhenNull() {
- assertNull(AbstractRecipientRewriteTable.sortMappings(null));
+ assertThat(AbstractRecipientRewriteTable.sortMappings(null)).isNull();
}
@Test
public void sortMappingsShouldReturnEmptyWhenEmpty() {
- assertEquals("", AbstractRecipientRewriteTable.sortMappings(""));
+
assertThat(AbstractRecipientRewriteTable.sortMappings("")).isEqualTo("");
}
@Test
public void sortMappingsShouldReturnSameStringWhenSingleDomainAlias() {
String singleDomainAlias = RecipientRewriteTable.ALIASDOMAIN_PREFIX +
"first";
- assertEquals(singleDomainAlias,
AbstractRecipientRewriteTable.sortMappings(singleDomainAlias));
+
assertThat(AbstractRecipientRewriteTable.sortMappings(singleDomainAlias)).isEqualTo(singleDomainAlias);
}
@Test
@@ -321,7 +315,7 @@ public abstract class AbstractRecipientR
String firstAliasMapping = RecipientRewriteTable.ALIASDOMAIN_PREFIX +
"first";
String secondAliasMapping = RecipientRewriteTable.ALIASDOMAIN_PREFIX +
"second";
String mappings =
MappingsImpl.fromCollection(Arrays.asList(firstAliasMapping,
secondAliasMapping)).serialize();
- assertEquals(mappings,
AbstractRecipientRewriteTable.sortMappings(mappings));
+
assertThat(AbstractRecipientRewriteTable.sortMappings(mappings)).isEqualTo(mappings);
}
@Test
@@ -330,7 +324,7 @@ public abstract class AbstractRecipientR
String domainMapping = RecipientRewriteTable.ALIASDOMAIN_PREFIX +
"second";
String inputMappings =
MappingsImpl.fromCollection(Arrays.asList(regexMapping,
domainMapping)).serialize();
String expectedMappings =
MappingsImpl.fromCollection(Arrays.asList(domainMapping,
regexMapping)).serialize();
- assertEquals(expectedMappings,
AbstractRecipientRewriteTable.sortMappings(inputMappings));
+
assertThat(AbstractRecipientRewriteTable.sortMappings(inputMappings)).isEqualTo(expectedMappings);
}
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
