Repository: james-project
Updated Branches:
  refs/heads/master 6c6efcd12 -> 1a8af22d4


http://git-wip-us.apache.org/repos/asf/james-project/blob/e627ae61/server/protocols/jmap-integration-testing/jmap-integration-testing-common/src/test/java/org/apache/james/jmap/methods/integration/GetMessageListMethodTest.java
----------------------------------------------------------------------
diff --git 
a/server/protocols/jmap-integration-testing/jmap-integration-testing-common/src/test/java/org/apache/james/jmap/methods/integration/GetMessageListMethodTest.java
 
b/server/protocols/jmap-integration-testing/jmap-integration-testing-common/src/test/java/org/apache/james/jmap/methods/integration/GetMessageListMethodTest.java
index 789d4f7..771b3c0 100644
--- 
a/server/protocols/jmap-integration-testing/jmap-integration-testing-common/src/test/java/org/apache/james/jmap/methods/integration/GetMessageListMethodTest.java
+++ 
b/server/protocols/jmap-integration-testing/jmap-integration-testing-common/src/test/java/org/apache/james/jmap/methods/integration/GetMessageListMethodTest.java
@@ -80,8 +80,8 @@ public abstract class GetMessageListMethodTest {
 
     protected abstract void await();
 
-    private AccessToken accessToken;
-    private String username;
+    private AccessToken aliceAccessToken;
+    private String alice;
     private String domain;
     private GuiceJamesServer jmapServer;
     private MailboxProbe mailboxProbe;
@@ -102,11 +102,11 @@ public abstract class GetMessageListMethodTest {
                 .build();
 
         this.domain = "domain.tld";
-        this.username = "username@" + domain;
+        this.alice = "alice@" + domain;
         String password = "password";
         dataProbe.addDomain(domain);
-        dataProbe.addUser(username, password);
-        this.accessToken = 
HttpJmapAuthentication.authenticateJamesUser(baseUri(), username, password);
+        dataProbe.addUser(alice, password);
+        this.aliceAccessToken = 
HttpJmapAuthentication.authenticateJamesUser(baseUri(), alice, password);
     }
 
     private URIBuilder baseUri() {
@@ -125,18 +125,18 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void getMessageListShouldNotDuplicateMessagesInSeveralMailboxes() 
throws Exception {
-        MailboxId mailboxId = 
mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
-        MailboxId mailboxId2 = 
mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox2");
+        MailboxId mailboxId = 
mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, "mailbox");
+        MailboxId mailboxId2 = 
mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, "mailbox2");
 
-        ComposedMessageId message = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
             new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
 
         await();
 
-        
jmapServer.getProbe(JmapGuiceProbe.class).setInMailboxes(message.getMessageId(),
 username, mailboxId, mailboxId2);
+        
jmapServer.getProbe(JmapGuiceProbe.class).setInMailboxes(message.getMessageId(),
 alice, mailboxId, mailboxId2);
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -148,17 +148,17 @@ public abstract class GetMessageListMethodTest {
     
     @Test
     public void getMessageListSetFlaggedFilterShouldResultFlaggedMessages() 
throws Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
-        ComposedMessageId messageNotFlagged = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageNotFlagged = 
mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, "mailbox"),
             new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
-        ComposedMessageId messageFlagged = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageFlagged = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
             ClassLoader.getSystemResourceAsStream("eml/twoAttachments.eml"), 
new Date(), false, new Flags(Flags.Flag.FLAGGED));
 
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", 
{\"filter\":{\"isFlagged\":\"true\"}}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -172,17 +172,17 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void 
getMessageListUnsetFlaggedFilterShouldReturnNotFlaggedMessages() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
-        ComposedMessageId messageNotFlagged = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageNotFlagged = 
mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, "mailbox"),
             new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
-        ComposedMessageId messageFlagged = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageFlagged = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
             ClassLoader.getSystemResourceAsStream("eml/twoAttachments.eml"), 
new Date(), false, new Flags(Flags.Flag.FLAGGED));
 
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", 
{\"filter\":{\"isFlagged\":\"false\"}}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -196,17 +196,17 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void getMessageListReadFilterShouldReturnOnlyReadMessages() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
-        ComposedMessageId messageNotRead = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageNotRead = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
             new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
-        ComposedMessageId messageRead = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageRead = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
             ClassLoader.getSystemResourceAsStream("eml/twoAttachments.eml"), 
new Date(), false, new Flags(Flags.Flag.SEEN));
 
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", 
{\"filter\":{\"isUnread\":\"false\"}}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -220,17 +220,17 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void getMessageListUnreadFilterShouldReturnOnlyUnreadMessages() 
throws Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
-        ComposedMessageId messageNotRead = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageNotRead = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
             new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
-        ComposedMessageId messageRead = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageRead = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
             ClassLoader.getSystemResourceAsStream("eml/twoAttachments.eml"), 
new Date(), false, new Flags(Flags.Flag.SEEN));
 
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"filter\":{\"isUnread\":\"true\"}}, 
\"#0\"]]")
         .when()
             .post("/jmap")
@@ -244,17 +244,17 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void getMessageListSetDraftFilterShouldReturnOnlyDraftMessages() 
throws Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
-        ComposedMessageId messageNotDraft = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageNotDraft = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
             new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
-        ComposedMessageId messageDraft = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageDraft = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
             ClassLoader.getSystemResourceAsStream("eml/twoAttachments.eml"), 
new Date(), false, new Flags(Flags.Flag.DRAFT));
 
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"filter\":{\"isDraft\":\"true\"}}, 
\"#0\"]]")
         .when()
             .post("/jmap")
@@ -268,17 +268,17 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void 
getMessageListUnsetDraftFilterShouldReturnOnlyNonDraftMessages() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
-        ComposedMessageId messageNotDraft = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageNotDraft = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
             new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
-        ComposedMessageId messageDraft = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageDraft = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
             ClassLoader.getSystemResourceAsStream("eml/twoAttachments.eml"), 
new Date(), false, new Flags(Flags.Flag.DRAFT));
 
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"filter\":{\"isDraft\":\"false\"}}, 
\"#0\"]]")
         .when()
             .post("/jmap")
@@ -292,17 +292,17 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void 
getMessageListSetAnsweredFilterShouldReturnOnlyAnsweredMessages() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
-        ComposedMessageId messageNotAnswered = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageNotAnswered = 
mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, "mailbox"),
             new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
-        ComposedMessageId messageAnswered = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageAnswered = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
             ClassLoader.getSystemResourceAsStream("eml/twoAttachments.eml"), 
new Date(), false, new Flags(Flags.Flag.ANSWERED));
 
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", 
{\"filter\":{\"isAnswered\":\"true\"}}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -316,17 +316,17 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void 
getMessageListUnsetAnsweredFilterShouldReturnOnlyNotAnsweredMessages() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
-        ComposedMessageId messageNotAnswered = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageNotAnswered = 
mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, "mailbox"),
             new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
-        ComposedMessageId messageAnswered = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageAnswered = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
             ClassLoader.getSystemResourceAsStream("eml/twoAttachments.eml"), 
new Date(), false, new Flags(Flags.Flag.ANSWERED));
 
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", 
{\"filter\":{\"isAnswered\":\"false\"}}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -340,21 +340,21 @@ public abstract class GetMessageListMethodTest {
     
     @Test
     public void 
getMessageListANDOperatorShouldReturnMessagesWhichMatchAllConditions() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
-        ComposedMessageId messageNotSeenNotFlagged = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageNotSeenNotFlagged = 
mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, "mailbox"),
             new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
-        ComposedMessageId messageNotSeenFlagged = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageNotSeenFlagged = 
mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, "mailbox"),
             ClassLoader.getSystemResourceAsStream("eml/twoAttachments.eml"), 
new Date(), false, new Flags(Flags.Flag.FLAGGED));
-        ComposedMessageId messageSeenNotFlagged = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageSeenNotFlagged = 
mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, "mailbox"),
             ClassLoader.getSystemResourceAsStream("eml/oneInlinedImage.eml"), 
new Date(), false, new Flags(Flags.Flag.SEEN));
-        ComposedMessageId messageSeenFlagged = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageSeenFlagged = 
mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, "mailbox"),
             ClassLoader.getSystemResourceAsStream("eml/oneInlinedImage.eml"), 
new Date(), false, FlagsBuilder.builder().add(Flags.Flag.SEEN, 
Flags.Flag.FLAGGED).build());
 
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", 
{\"filter\":{\"operator\":\"AND\",\"conditions\":[{\"isFlagged\":\"true\"},{\"isUnread\":\"true\"}]}},
 \"#0\"]]")
         .when()
             .post("/jmap")
@@ -370,21 +370,21 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void 
getMessageListOROperatorShouldReturnMessagesWhichMatchOneOfAllConditions() 
throws Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
-        ComposedMessageId messageNotSeenNotFlagged = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageNotSeenNotFlagged = 
mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, "mailbox"),
             new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
-        ComposedMessageId messageNotSeenFlagged = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageNotSeenFlagged = 
mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, "mailbox"),
             ClassLoader.getSystemResourceAsStream("eml/twoAttachments.eml"), 
new Date(), false, new Flags(Flags.Flag.FLAGGED));
-        ComposedMessageId messageSeenNotFlagged = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageSeenNotFlagged = 
mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, "mailbox"),
             ClassLoader.getSystemResourceAsStream("eml/oneInlinedImage.eml"), 
new Date(), false, new Flags(Flags.Flag.SEEN));
-        ComposedMessageId messageSeenFlagged = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageSeenFlagged = 
mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, "mailbox"),
             ClassLoader.getSystemResourceAsStream("eml/oneInlinedImage.eml"), 
new Date(), false, FlagsBuilder.builder().add(Flags.Flag.SEEN, 
Flags.Flag.FLAGGED).build());
 
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", 
{\"filter\":{\"operator\":\"OR\",\"conditions\":[{\"isFlagged\":\"true\"},{\"isUnread\":\"true\"}]}},
 \"#0\"]]")
         .when()
             .post("/jmap")
@@ -400,21 +400,21 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void 
getMessageListNOTOperatorShouldReturnMessagesWhichNotMatchAnyCondition() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
-        ComposedMessageId messageNotSeenNotFlagged = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageNotSeenNotFlagged = 
mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, "mailbox"),
             new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
-        ComposedMessageId messageNotSeenFlagged = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageNotSeenFlagged = 
mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, "mailbox"),
             ClassLoader.getSystemResourceAsStream("eml/twoAttachments.eml"), 
new Date(), false, new Flags(Flags.Flag.FLAGGED));
-        ComposedMessageId messageSeenNotFlagged = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageSeenNotFlagged = 
mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, "mailbox"),
             ClassLoader.getSystemResourceAsStream("eml/oneInlinedImage.eml"), 
new Date(), false, new Flags(Flags.Flag.SEEN));
-        ComposedMessageId messageSeenFlagged = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageSeenFlagged = 
mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, "mailbox"),
             ClassLoader.getSystemResourceAsStream("eml/oneInlinedImage.eml"), 
new Date(), false, FlagsBuilder.builder().add(Flags.Flag.SEEN, 
Flags.Flag.FLAGGED).build());
 
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", 
{\"filter\":{\"operator\":\"NOT\",\"conditions\":[{\"isFlagged\":\"true\"},{\"isUnread\":\"true\"}]}},
 \"#0\"]]")
         .when()
             .post("/jmap")
@@ -430,21 +430,21 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void 
getMessageListNestedOperatorsShouldReturnMessagesWhichMatchConditions() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
-        ComposedMessageId messageNotSeenNotFlagged = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageNotSeenNotFlagged = 
mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, "mailbox"),
             new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
-        ComposedMessageId messageNotSeenFlagged = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageNotSeenFlagged = 
mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, "mailbox"),
             ClassLoader.getSystemResourceAsStream("eml/twoAttachments.eml"), 
new Date(), false, new Flags(Flags.Flag.FLAGGED));
-        ComposedMessageId messageSeenNotFlagged = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageSeenNotFlagged = 
mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, "mailbox"),
             ClassLoader.getSystemResourceAsStream("eml/oneInlinedImage.eml"), 
new Date(), false, new Flags(Flags.Flag.SEEN));
-        ComposedMessageId messageSeenFlagged = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageSeenFlagged = 
mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, "mailbox"),
             ClassLoader.getSystemResourceAsStream("eml/oneInlinedImage.eml"), 
new Date(), false, FlagsBuilder.builder().add(Flags.Flag.SEEN, 
Flags.Flag.FLAGGED).build());
 
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", 
{\"filter\":{\"operator\":\"OR\",\"conditions\":[" +
                 "{\"operator\":\"AND\", 
\"conditions\":[{\"isFlagged\":\"true\"},{\"isUnread\":\"true\"}]}," +
                 "{\"operator\":\"AND\", 
\"conditions\":[{\"isFlagged\":\"true\"},{\"isUnread\":\"false\"}]}" +
@@ -464,7 +464,7 @@ public abstract class GetMessageListMethodTest {
     @Test
     public void 
getMessageListShouldReturnErrorInvalidArgumentsWhenRequestIsInvalid() throws 
Exception {
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"filter\": true}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -477,7 +477,7 @@ public abstract class GetMessageListMethodTest {
     @Test
     public void 
getMessageListShouldReturnErrorInvalidArgumentsWhenHeaderIsInvalid() throws 
Exception {
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"filter\":{\"header\":[\"132\", 
\"456\", \"789\"]}}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -489,18 +489,18 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void getMessageListShouldSupportHasAttachmentSetToTrue() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
-        mailboxProbe.appendMessage(username, MailboxPath.forUser(username, 
"mailbox"),
+        mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, 
"mailbox"),
             new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
-        ComposedMessageId message2 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message2 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
             ClassLoader.getSystemResourceAsStream("eml/twoAttachments.eml"), 
new Date(), false, new Flags());
-        mailboxProbe.appendMessage(username, MailboxPath.forUser(username, 
"mailbox"),
+        mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, 
"mailbox"),
             ClassLoader.getSystemResourceAsStream("eml/oneInlinedImage.eml"), 
new Date(), false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", 
{\"filter\":{\"hasAttachment\":\"true\"}}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -512,18 +512,18 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void getMessageListShouldSupportHasAttachmentSetToFalse() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
-        ComposedMessageId message1 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message1 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
             new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
-        mailboxProbe.appendMessage(username, MailboxPath.forUser(username, 
"mailbox"),
+        mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, 
"mailbox"),
             ClassLoader.getSystemResourceAsStream("eml/twoAttachments.eml"), 
new Date(), false, new Flags());
-        ComposedMessageId message3 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message3 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
             ClassLoader.getSystemResourceAsStream("eml/oneInlinedImage.eml"), 
new Date(), false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", 
{\"filter\":{\"hasAttachment\":\"false\"}}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -536,7 +536,7 @@ public abstract class GetMessageListMethodTest {
     @Test
     public void getMessageListShouldNotFailWhenHeaderIsValid() throws 
Exception {
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"filter\":{\"header\":[\"132\", 
\"456\"]}}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -547,16 +547,16 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void 
getMessageListShouldReturnAllMessagesWhenSingleMailboxNoParameters() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
-        ComposedMessageId message1 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message1 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
-        ComposedMessageId message2 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message2 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Subject: 
test2\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -568,17 +568,17 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void 
getMessageListShouldReturnAllMessagesWhenMultipleMailboxesAndNoParameters() 
throws Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
-        ComposedMessageId message1 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
+        ComposedMessageId message1 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
 
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox2");
-        ComposedMessageId message2 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox2"),
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox2");
+        ComposedMessageId message2 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox2"),
                 new ByteArrayInputStream("Subject: 
test2\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -594,12 +594,12 @@ public abstract class GetMessageListMethodTest {
         String password = "password";
         dataProbe.addUser(otherUser, password);
 
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
-        ComposedMessageId message1 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
+        ComposedMessageId message1 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
 
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox2");
-        ComposedMessageId message2 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox2"),
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox2");
+        ComposedMessageId message2 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox2"),
                 new ByteArrayInputStream("Subject: 
test2\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
         await();
 
@@ -609,7 +609,7 @@ public abstract class GetMessageListMethodTest {
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -621,13 +621,13 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void 
getMessageListShouldFilterMessagesWhenInMailboxesFilterMatches() throws 
Exception {
-        MailboxId mailboxId = 
mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
-        ComposedMessageId message = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        MailboxId mailboxId = 
mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, "mailbox");
+        ComposedMessageId message = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"filter\":{\"inMailboxes\":[\"" + 
mailboxId.serialize() + "\"]}}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -639,15 +639,15 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void 
getMessageListShouldFilterMessagesWhenMultipleInMailboxesFilterMatches() throws 
Exception {
-        MailboxId mailboxId = 
mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
-        ComposedMessageId message = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        MailboxId mailboxId = 
mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, "mailbox");
+        ComposedMessageId message = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
 
-        MailboxId mailboxId2 = 
mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox2");
+        MailboxId mailboxId2 = 
mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, "mailbox2");
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body(String.format("[[\"getMessageList\", 
{\"filter\":{\"inMailboxes\":[\"%s\", \"%s\"]}}, \"#0\"]]", 
mailboxId.serialize(), mailboxId2.serialize()))
         .when()
             .post("/jmap")
@@ -659,14 +659,14 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void 
getMessageListShouldFilterMessagesWhenNotInMailboxesFilterMatches() throws 
Exception {
-        MailboxId mailboxId = 
mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
-        mailboxProbe.appendMessage(username, MailboxPath.forUser(username, 
"mailbox"),
+        MailboxId mailboxId = 
mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, "mailbox");
+        mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, 
"mailbox"),
                 new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
 
         await();
         
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body(String.format("[[\"getMessageList\", 
{\"filter\":{\"notInMailboxes\":[\"%s\"]}}, \"#0\"]]", mailboxId.serialize()))
         .when()
             .post("/jmap")
@@ -678,17 +678,17 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void 
getMessageListShouldFilterMessagesWhenNotInMailboxesFilterMatchesTwice() throws 
Exception {
-        MailboxId mailboxId = 
mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
-        mailboxProbe.appendMessage(username, MailboxPath.forUser(username, 
"mailbox"),
+        MailboxId mailboxId = 
mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, "mailbox");
+        mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, 
"mailbox"),
                 new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
 
-        MailboxId mailbox2Id = 
mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox2");
-        mailboxProbe.appendMessage(username, MailboxPath.forUser(username, 
"mailbox2"),
+        MailboxId mailbox2Id = 
mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, "mailbox2");
+        mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, 
"mailbox2"),
                 new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body(String.format("[[\"getMessageList\", 
{\"filter\":{\"notInMailboxes\":[\"%s\", \"%s\"]}}, \"#0\"]]", 
mailboxId.serialize(), mailbox2Id.serialize()))
         .when()
             .post("/jmap")
@@ -700,13 +700,13 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void 
getMessageListShouldFilterMessagesWhenIdenticalNotInMailboxesAndInmailboxesFilterMatch()
 throws Exception {
-        MailboxId mailboxId = 
mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
-        mailboxProbe.appendMessage(username, MailboxPath.forUser(username, 
"mailbox"),
+        MailboxId mailboxId = 
mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, "mailbox");
+        mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, 
"mailbox"),
                 new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body(String.format("[[\"getMessageList\", 
{\"filter\":{\"notInMailboxes\":[\"%s\"], \"inMailboxes\":[\"%s\"]}}, 
\"#0\"]]", mailboxId.serialize(), mailboxId.serialize()))
         .when()
             .post("/jmap")
@@ -718,15 +718,15 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void 
getMessageListShouldNotFilterMessagesWhenNotInMailboxesFilterDoesNotMatch() 
throws Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
-        ComposedMessageId message = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
+        ComposedMessageId message = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
 
-        MailboxId mailbox2Id = 
mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox2");
+        MailboxId mailbox2Id = 
mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, "mailbox2");
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body(String.format("[[\"getMessageList\", 
{\"filter\":{\"notInMailboxes\":[\"%s\"]}}, \"#0\"]]", mailbox2Id.serialize()))
         .when()
             .post("/jmap")
@@ -738,15 +738,15 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void 
getMessageListShouldNotFilterMessagesWhenEmptyNotInMailboxesFilter() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
-        ComposedMessageId message = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
+        ComposedMessageId message = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
 
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox2");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox2");
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"filter\":{\"notInMailboxes\":[]}}, 
\"#0\"]]")
         .when()
             .post("/jmap")
@@ -758,15 +758,15 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void 
getMessageListShouldFilterMessagesWhenInMailboxesFilterDoesntMatches() throws 
Exception {
-        MailboxId emptyMailboxId = 
mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"emptyMailbox");
+        MailboxId emptyMailboxId = 
mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"emptyMailbox");
 
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
-        mailboxProbe.appendMessage(username, MailboxPath.forUser(username, 
"mailbox"),
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
+        mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, 
"mailbox"),
                 new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body(String.format("[[\"getMessageList\", 
{\"filter\":{\"inMailboxes\":[\"%s\"]}}, \"#0\"]]", emptyMailboxId.serialize()))
         .when()
             .post("/jmap")
@@ -777,13 +777,13 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void 
getMessageListShouldFilterMessagesWhenTextFilterDoesntMatches() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
-        mailboxProbe.appendMessage(username, MailboxPath.forUser(username, 
"mailbox"),
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
+        mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, 
"mailbox"),
                 new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body(String.format("[[\"getMessageList\", 
{\"filter\":{\"text\":\"bad\"}}, \"#0\"]]"))
         .when()
             .post("/jmap")
@@ -794,13 +794,13 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void 
getMessageListShouldNotFilterMessagesWhenTextFilterMatchesBody() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
-        ComposedMessageId message = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
+        ComposedMessageId message = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 
ClassLoader.getSystemResourceAsStream("eml/twoAttachments.eml"), new Date(), 
false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body(String.format("[[\"getMessageList\", 
{\"filter\":{\"text\":\"html\"}}, \"#0\"]]"))
         .when()
             .post("/jmap")
@@ -811,7 +811,7 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void 
getMessageListShouldFilterMessagesWhenAttachmentFilterDoesntMatches() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
         byte[] attachmentContent = 
IOUtils.toByteArray(ClassLoader.getSystemResourceAsStream("eml/attachment.pdf"));
         BodyPart attachment = BodyPartBuilder.create()
                 .setBody(attachmentContent, "application/pdf")
@@ -828,12 +828,12 @@ public abstract class GetMessageListMethodTest {
         ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
         MessageWriter writer = new DefaultMessageWriter();
         writer.writeMessage(message, outputStream);
-        mailboxProbe.appendMessage(username, MailboxPath.forUser(username, 
"mailbox"),
+        mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, 
"mailbox"),
                 new ByteArrayInputStream(outputStream.toByteArray()), new 
Date(), false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body(String.format("[[\"getMessageList\", 
{\"filter\":{\"attachments\":\"no apple inside\"}}, \"#0\"]]"))
         .when()
             .post("/jmap")
@@ -844,7 +844,7 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void 
getMessageListShouldNotFilterMessagesWhenAttachmentFilterMatches() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
         byte[] attachmentContent = 
IOUtils.toByteArray(ClassLoader.getSystemResourceAsStream("eml/attachment.pdf"));
         BodyPart attachment = BodyPartBuilder.create()
                 .setBody(attachmentContent, "application/pdf")
@@ -861,12 +861,12 @@ public abstract class GetMessageListMethodTest {
         ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
         MessageWriter writer = new DefaultMessageWriter();
         writer.writeMessage(message, outputStream);
-        ComposedMessageId composedMessageId = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId composedMessageId = 
mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream(outputStream.toByteArray()), new 
Date(), false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body(String.format("[[\"getMessageList\", 
{\"filter\":{\"attachments\":\"beautiful banana\"}}, \"#0\"]]"))
         .when()
             .post("/jmap")
@@ -877,17 +877,17 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void getMessageListShouldSortMessagesWhenSortedByDateDefault() 
throws Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
         LocalDate date = LocalDate.now();
-        ComposedMessageId message1 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message1 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), convertToDate(date.plusDays(1)), false, new 
Flags());
-        ComposedMessageId message2 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message2 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Subject: 
test2\r\n\r\ntestmail".getBytes()), convertToDate(date), false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"sort\":[\"date\"]}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -899,18 +899,18 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void getMessageListShouldSortMessagesWhenDateDoesntHaveCentury() 
throws Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
         LocalDate date = LocalDate.parse("Wed, 28 Jun 17 09:23:01 +0200", 
ImapDateTimeFormatter.rfc5322());
-        ComposedMessageId message1 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message1 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), convertToDate(date.plusDays(1)), false, new 
Flags());
         LocalDate date2 = LocalDate.parse("Tue, 27 Jun 2017 09:23:01 +0200", 
ImapDateTimeFormatter.rfc5322());
-        ComposedMessageId message2 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message2 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Subject: 
test2\r\n\r\ntestmail".getBytes()), convertToDate(date2), false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"sort\":[\"date desc\"]}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -922,17 +922,17 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void getMessageListShouldSortMessagesWhenSortedByDateAsc() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
         LocalDate date = LocalDate.now();
-        ComposedMessageId message1 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message1 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Date: Fri, 02 Jun 2017 13:54:59 
+0200\r\nSubject: test\r\n\r\ntestmail".getBytes()), 
convertToDate(date.plusDays(1)), false, new Flags());
-        ComposedMessageId message2 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message2 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Date: Fri, 02 Jun 2017 14:54:59 
+0200\r\nSubject: test2\r\n\r\ntestmail".getBytes()), convertToDate(date), 
false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"sort\":[\"date asc\"]}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -944,17 +944,17 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void getMessageListShouldSortMessagesWhenSortedBySubjectAsc() 
throws Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
         LocalDate date = LocalDate.now();
-        ComposedMessageId message1 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message1 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Date: Fri, 02 Jun 2017 13:54:59 
+0200\r\nSubject: a subject\r\n\r\ntestmail".getBytes()), convertToDate(date), 
false, new Flags());
-        ComposedMessageId message2 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message2 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Date: Fri, 02 Jun 2017 14:54:59 
+0200\r\nSubject: b subject\r\n\r\ntestmail".getBytes()), convertToDate(date), 
false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"sort\":[\"subject asc\"]}, 
\"#0\"]]")
         .when()
             .post("/jmap")
@@ -966,17 +966,17 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void getMessageListShouldSortMessagesWhenSortedBySubjectDesc() 
throws Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
         LocalDate date = LocalDate.now();
-        ComposedMessageId message1 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message1 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Date: Fri, 02 Jun 2017 13:54:59 
+0200\r\nSubject: a subject\r\n\r\ntestmail".getBytes()), convertToDate(date), 
false, new Flags());
-        ComposedMessageId message2 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message2 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Date: Fri, 02 Jun 2017 14:54:59 
+0200\r\nSubject: b subject\r\n\r\ntestmail".getBytes()), convertToDate(date), 
false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"sort\":[\"subject desc\"]}, 
\"#0\"]]")
         .when()
             .post("/jmap")
@@ -988,17 +988,17 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void getMessageListShouldSortMessagesWhenSortedByFromAsc() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
         LocalDate date = LocalDate.now();
-        ComposedMessageId message1 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message1 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Date: Fri, 02 Jun 2017 13:54:59 
+0200\r\nSubject: subject\r\nFrom: bbb\r\n\r\ntestmail".getBytes()), 
convertToDate(date), false, new Flags());
-        ComposedMessageId message2 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message2 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Date: Fri, 02 Jun 2017 14:54:59 
+0200\r\nSubject: subject\r\nFrom: aaa\r\n\r\ntestmail".getBytes()), 
convertToDate(date), false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"sort\":[\"from asc\"]}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -1010,17 +1010,17 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void getMessageListShouldSortMessagesWhenSortedByFromDesc() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
         LocalDate date = LocalDate.now();
-        ComposedMessageId message1 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message1 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Date: Fri, 02 Jun 2017 13:54:59 
+0200\r\nSubject: subject\r\nFrom: aaa\r\n\r\ntestmail".getBytes()), 
convertToDate(date), false, new Flags());
-        ComposedMessageId message2 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message2 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Date: Fri, 02 Jun 2017 14:54:59 
+0200\r\nSubject: subject\r\nFrom: bbb\r\n\r\ntestmail".getBytes()), 
convertToDate(date), false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"sort\":[\"from desc\"]}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -1032,17 +1032,17 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void getMessageListShouldSortMessagesWhenSortedByToAsc() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
         LocalDate date = LocalDate.now();
-        ComposedMessageId message1 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message1 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Date: Fri, 02 Jun 2017 13:54:59 
+0200\r\nSubject: subject\r\nTo: bbb\r\n\r\ntestmail".getBytes()), 
convertToDate(date), false, new Flags());
-        ComposedMessageId message2 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message2 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Date: Fri, 02 Jun 2017 14:54:59 
+0200\r\nSubject: subject\r\nTo: aaa\r\n\r\ntestmail".getBytes()), 
convertToDate(date), false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"sort\":[\"to asc\"]}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -1054,17 +1054,17 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void getMessageListShouldSortMessagesWhenSortedByToDesc() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
         LocalDate date = LocalDate.now();
-        ComposedMessageId message1 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message1 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Date: Fri, 02 Jun 2017 13:54:59 
+0200\r\nSubject: subject\r\nTo: aaa\r\n\r\ntestmail".getBytes()), 
convertToDate(date), false, new Flags());
-        ComposedMessageId message2 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message2 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Date: Fri, 02 Jun 2017 14:54:59 
+0200\r\nSubject: subject\r\nTo: bbb\r\n\r\ntestmail".getBytes()), 
convertToDate(date), false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"sort\":[\"to desc\"]}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -1077,17 +1077,17 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void getMessageListShouldSortMessagesWhenSortedBySizeAsc() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
         LocalDate date = LocalDate.now();
-        ComposedMessageId message1 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message1 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Date: Fri, 02 Jun 2017 13:54:59 
+0200\r\nSubject: subject\r\n\r\ntestmail".getBytes()), convertToDate(date), 
false, new Flags());
-        ComposedMessageId message2 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message2 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Date: Fri, 02 Jun 2017 14:54:59 
+0200\r\nSubject: subject\r\n\r\ntestmail bigger".getBytes()), 
convertToDate(date), false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"sort\":[\"size asc\"]}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -1099,17 +1099,17 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void getMessageListShouldSortMessagesWhenSortedBySizeDesc() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
         LocalDate date = LocalDate.now();
-        ComposedMessageId message1 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message1 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Date: Fri, 02 Jun 2017 13:54:59 
+0200\r\nSubject: subject\r\n\r\ntestmail".getBytes()), convertToDate(date), 
false, new Flags());
-        ComposedMessageId message2 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message2 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Date: Fri, 02 Jun 2017 14:54:59 
+0200\r\nSubject: subject\r\n\r\ntestmail bigger".getBytes()), 
convertToDate(date), false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"sort\":[\"size desc\"]}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -1121,20 +1121,20 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void getMessageListShouldSortMessagesWhenSortedBySizeAndDateAsc() 
throws Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
         LocalDate date = LocalDate.now();
-        ComposedMessageId message1 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message1 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Date: Fri, 02 Jun 2017 13:54:59 
+0200\r\nSubject: test\r\n\r\ntestmail really bigger".getBytes()), 
convertToDate(date.plusDays(1)), false, new Flags());
-        ComposedMessageId message2 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message2 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Date: Fri, 02 Jun 2017 14:54:59 
+0200\r\nSubject: test\r\n\r\ntestmail smaller".getBytes()), 
convertToDate(date), false, new Flags());
-        ComposedMessageId message3 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message3 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Date: Fri, 02 Jun 2017 15:54:59 
+0200\r\nSubject: test\r\n\r\ntestmail really bigger".getBytes()), 
convertToDate(date.plusDays(1)), false, new Flags());
 
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"sort\":[\"size asc\", \"date 
desc\"]}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -1146,20 +1146,20 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void getMessageListShouldSortMessagesWhenSortedByDateAndSizeAsc() 
throws Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
         LocalDate date = LocalDate.now();
-        ComposedMessageId message1 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message1 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Date: Fri, 02 Jun 2017 13:54:59 
+0200\r\nSubject: test\r\n\r\ntestmail really bigger".getBytes()), 
convertToDate(date), false, new Flags());
-        ComposedMessageId message2 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message2 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Date: Fri, 02 Jun 2017 13:54:59 
+0200\r\nSubject: test\r\n\r\ntestmail smaller".getBytes()), 
convertToDate(date), false, new Flags());
-        ComposedMessageId message3 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message3 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Date: Fri, 02 Jun 2017 15:54:59 
+0200\r\nSubject: test\r\n\r\ntestmail really bigger".getBytes()), 
convertToDate(date), false, new Flags());
 
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"sort\":[\"date desc\", \"size 
asc\"]}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -1171,17 +1171,17 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void getMessageListShouldSupportIdSorting() throws Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
         LocalDate date = LocalDate.now();
-        ComposedMessageId message1 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message1 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
             new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), convertToDate(date.plusDays(1)), false, new 
Flags());
-        ComposedMessageId message2 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message2 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
             new ByteArrayInputStream("Subject: 
test2\r\n\r\ntestmail".getBytes()), convertToDate(date), false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"sort\":[\"id\"]}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -1193,17 +1193,17 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void getMessageListShouldSortMessagesWhenSortedByDateDesc() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
         LocalDate date = LocalDate.now();
-        ComposedMessageId message1 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message1 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), convertToDate(date.plusDays(1)), false, new 
Flags());
-        ComposedMessageId message2 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message2 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Subject: 
test2\r\n\r\ntestmail".getBytes()), convertToDate(date), false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"sort\":[\"date desc\"]}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -1216,7 +1216,7 @@ public abstract class GetMessageListMethodTest {
     @Test
     public void getMessageListShouldWorkWhenCollapseThreadIsFalse() {
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"collapseThreads\":false}, 
\"#0\"]]")
         .when()
             .post("/jmap")
@@ -1228,7 +1228,7 @@ public abstract class GetMessageListMethodTest {
     @Test
     public void getMessageListShouldWorkWhenCollapseThreadIsTrue() {
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"collapseThreads\":true}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -1239,17 +1239,17 @@ public abstract class GetMessageListMethodTest {
     
     @Test
     public void getMessageListShouldReturnAllMessagesWhenPositionIsNotGiven() 
throws Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
         LocalDate date = LocalDate.now();
-        ComposedMessageId message1 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message1 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), convertToDate(date.plusDays(1)), false, new 
Flags());
-        ComposedMessageId message2 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message2 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Subject: 
test2\r\n\r\ntestmail".getBytes()), convertToDate(date), false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -1261,17 +1261,17 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void getMessageListShouldReturnSkipMessagesWhenPositionIsGiven() 
throws Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
         LocalDate date = LocalDate.now();
-        mailboxProbe.appendMessage(username, MailboxPath.forUser(username, 
"mailbox"),
+        mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, 
"mailbox"),
                 new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), convertToDate(date.plusDays(1)), false, new 
Flags());
-        ComposedMessageId message2 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message2 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Subject: 
test2\r\n\r\ntestmail".getBytes()), convertToDate(date), false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"position\":1, \"sort\":[\"date 
desc\"]}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -1283,19 +1283,19 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void 
getMessageListShouldReturnSkipMessagesWhenPositionAndLimitGiven() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
         LocalDate date = LocalDate.now();
-        mailboxProbe.appendMessage(username, MailboxPath.forUser(username, 
"mailbox"),
+        mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, 
"mailbox"),
             new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), convertToDate(date.plusDays(2)), false, new 
Flags());
-        ComposedMessageId message2 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message2 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
             new ByteArrayInputStream("Subject: 
test2\r\n\r\ntestmail".getBytes()), convertToDate(date.plusDays(1)), false, new 
Flags());
-        mailboxProbe.appendMessage(username, MailboxPath.forUser(username, 
"mailbox"),
+        mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, 
"mailbox"),
             new ByteArrayInputStream("Subject: 
test3\r\n\r\ntestmail".getBytes()), convertToDate(date), false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"position\":1, \"limit\":1, 
\"sort\":[\"date desc\"]}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -1307,17 +1307,17 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void getMessageListShouldReturnAllMessagesWhenLimitIsNotGiven() 
throws Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
         LocalDate date = LocalDate.now();
-        ComposedMessageId message1 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message1 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), convertToDate(date.plusDays(1)), false, new 
Flags());
-        ComposedMessageId message2 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message2 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Subject: 
test2\r\n\r\ntestmail".getBytes()), convertToDate(date), false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -1329,17 +1329,17 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void getMessageListShouldReturnLimitMessagesWhenLimitGiven() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
         LocalDate date = LocalDate.now();
-        ComposedMessageId message = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), convertToDate(date.plusDays(1)), false, new 
Flags());
-        mailboxProbe.appendMessage(username, MailboxPath.forUser(username, 
"mailbox"),
+        mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, 
"mailbox"),
                 new ByteArrayInputStream("Subject: 
test2\r\n\r\ntestmail".getBytes()), convertToDate(date), false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"limit\":1}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -1351,21 +1351,21 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void 
getMessageListShouldReturnLimitMessagesWithDefaultValueWhenLimitIsNotGiven() 
throws Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
         LocalDate date = LocalDate.now();
-        ComposedMessageId message1 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message1 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), convertToDate(date.plusDays(1)), false, new 
Flags());
-        ComposedMessageId message2 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message2 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Subject: 
test2\r\n\r\ntestmail".getBytes()), convertToDate(date), false, new Flags());
-        ComposedMessageId message3 = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message3 = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Subject: 
test3\r\n\r\ntestmail".getBytes()), convertToDate(date), false, new Flags());
-        mailboxProbe.appendMessage(username, MailboxPath.forUser(username, 
"mailbox"),
+        mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, 
"mailbox"),
                 new ByteArrayInputStream("Subject: 
test4\r\n\r\ntestmail".getBytes()), convertToDate(date), false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -1377,15 +1377,15 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void getMessageListShouldChainFetchingMessagesWhenAskedFor() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
         LocalDate date = LocalDate.now();
-        ComposedMessageId message = mailboxProbe.appendMessage(username, 
MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId message = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
                 new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), convertToDate(date.plusDays(1)), false, new 
Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"fetchMessages\":true}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -1401,19 +1401,19 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void getMessageListShouldComputeTextBodyWhenNoTextBodyButHtmlBody() 
throws Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
         String mailContent = "Content-Type: text/html\r\n"
             + "Subject: message 1 subject\r\n"
             + "\r\n"
             + "Hello <b>someone</b>, and thank you for joining example.com!";
         LocalDate date = LocalDate.now();
-        mailboxProbe.appendMessage(username, MailboxPath.forUser(username, 
"mailbox"),
+        mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, 
"mailbox"),
             new ByteArrayInputStream(mailContent.getBytes()), 
convertToDate(date.plusDays(1)), false, new Flags());
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", {\"fetchMessages\": true, 
\"fetchMessageProperties\": [\"htmlBody\", \"textBody\"]}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -1429,17 +1429,17 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void 
getMessageListHasKeywordFilterShouldReturnMessagesWithKeywords() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
-        ComposedMessageId messageNotFlagged = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageNotFlagged = 
mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, "mailbox"),
             new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
-        ComposedMessageId messageFlagged = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageFlagged = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
             new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new 
Flags(Flags.Flag.FLAGGED));
 
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", 
{\"filter\":{\"hasKeyword\":\"$Flagged\"}}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -1453,22 +1453,22 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void 
getMessageListHasKeywordFilterShouldReturnMessagesWithUserKeywords() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
         Flags flags = FlagsBuilder.builder()
             .add(Flags.Flag.FLAGGED)
             .add(FORWARDED)
             .build();
 
-        ComposedMessageId messageNotFlagged = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageNotFlagged = 
mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, "mailbox"),
             new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
-        ComposedMessageId messageFlagged = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageFlagged = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
             new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, flags);
 
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", 
{\"filter\":{\"operator\":\"AND\",\"conditions\":[{\"hasKeyword\":\"$Flagged\"},{\"hasKeyword\":\"$Forwarded\"}]}},
 \"#0\"]]")
         .when()
             .post("/jmap")
@@ -1482,17 +1482,17 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void 
getMessageListNotKeywordFilterShouldReturnMessagesWithoutKeywords() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
-        ComposedMessageId messageNotFlagged = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageNotFlagged = 
mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, "mailbox"),
             new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
-        ComposedMessageId messageFlagged = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageFlagged = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
             new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new 
Flags(Flags.Flag.FLAGGED));
 
         await();
 
         given()
-            .header("Authorization", accessToken.serialize())
+            .header("Authorization", aliceAccessToken.serialize())
             .body("[[\"getMessageList\", 
{\"filter\":{\"notKeyword\":\"$Flagged\"}}, \"#0\"]]")
         .when()
             .post("/jmap")
@@ -1506,22 +1506,22 @@ public abstract class GetMessageListMethodTest {
 
     @Test
     public void 
getMessageListNotKeywordFilterShouldReturnMessagesWithoutUserKeywords() throws 
Exception {
-        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, username, 
"mailbox");
+        mailboxProbe.createMailbox(MailboxConstants.USER_NAMESPACE, alice, 
"mailbox");
 
         Flags flags = FlagsBuilder.builder()
             .add(Flags.Flag.FLAGGED)
             .add(FORWARDED)
             .build();
 
-        ComposedMessageId messageNotFlagged = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageNotFlagged = 
mailboxProbe.appendMessage(alice, MailboxPath.forUser(alice, "mailbox"),
             new ByteArrayInputStream("Subject: 
test\r\n\r\ntestmail".getBytes()), new Date(), false, new Flags());
-        ComposedMessageId messageFlagged = 
mailboxProbe.appendMessage(username, MailboxPath.forUser(username, "mailbox"),
+        ComposedMessageId messageFlagged = mailboxProbe.appendMessage(alice, 
MailboxPath.forUser(alice, "mailbox"),
             new ByteArrayInputStream("Subject

<TRUNCATED>

---------------------------------------------------------------------
To unsubscribe, e-mail: server-dev-unsubscr...@james.apache.org
For additional commands, e-mail: server-dev-h...@james.apache.org

Reply via email to