http://git-wip-us.apache.org/repos/asf/james-project/blob/0cfb3951/mailbox/api/src/test/java/org/apache/james/mailbox/model/PrefixedRegexTest.java ---------------------------------------------------------------------- diff --git a/mailbox/api/src/test/java/org/apache/james/mailbox/model/PrefixedRegexTest.java b/mailbox/api/src/test/java/org/apache/james/mailbox/model/PrefixedRegexTest.java deleted file mode 100644 index 69b4ec9..0000000 --- a/mailbox/api/src/test/java/org/apache/james/mailbox/model/PrefixedRegexTest.java +++ /dev/null @@ -1,1058 +0,0 @@ -/**************************************************************** - * Licensed to the Apache Software Foundation (ASF) under one * - * or more contributor license agreements. See the NOTICE file * - * distributed with this work for additional information * - * regarding copyright ownership. The ASF licenses this file * - * to you under the Apache License, Version 2.0 (the * - * "License"); you may not use this file except in compliance * - * with the License. You may obtain a copy of the License at * - * * - * http://www.apache.org/licenses/LICENSE-2.0 * - * * - * Unless required by applicable law or agreed to in writing, * - * software distributed under the License is distributed on an * - * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * - * KIND, either express or implied. See the License for the * - * specific language governing permissions and limitations * - * under the License. * - ****************************************************************/ - -package org.apache.james.mailbox.model; - -import static org.assertj.core.api.Assertions.assertThat; - -import org.junit.Test; - -public class PrefixedRegexTest { - private static final char PATH_DELIMITER = '.'; - private static final String PREFIX = "name"; - private static final String EMPTY_PREFIX = ""; - - @Test - public void isWildShouldReturnTrueWhenOnlyFreeWildcard() throws Exception { - PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX, "*", PATH_DELIMITER); - - boolean actual = prefixedRegex.isWild(); - - assertThat(actual).isTrue(); - } - - @Test - public void isWildShouldReturnTrueWhenOnlyLocalWildcard() throws Exception { - PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX, "%", PATH_DELIMITER); - - boolean actual = prefixedRegex.isWild(); - - assertThat(actual).isTrue(); - } - - @Test - public void isWildShouldReturnTrueWhenFreeWildcardAtBeginning() throws Exception { - PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX, "*One", PATH_DELIMITER); - - boolean actual = prefixedRegex.isWild(); - - assertThat(actual).isTrue(); - } - - @Test - public void isWildShouldReturnTrueWhenLocalWildcardAtBeginning() throws Exception { - PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX, "%One", PATH_DELIMITER); - - boolean actual = prefixedRegex.isWild(); - - assertThat(actual).isTrue(); - } - - @Test - public void isWildShouldReturnTrueWhenFreeWildcardInMiddle() throws Exception { - PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX, "A*A", PATH_DELIMITER); - - boolean actual = prefixedRegex.isWild(); - - assertThat(actual).isTrue(); - } - - @Test - public void isWildShouldReturnTrueWhenLocalWildcardInMiddle() throws Exception { - PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX, "A%A", PATH_DELIMITER); - - boolean actual = prefixedRegex.isWild(); - - assertThat(actual).isTrue(); - } - - @Test - public void isWildShouldReturnTrueWhenFreeWildcardAtEnd() throws Exception { - PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX, "One*", PATH_DELIMITER); - - boolean actual = prefixedRegex.isWild(); - - assertThat(actual).isTrue(); - } - - @Test - public void isWildShouldReturnTrueWhenLocalWildcardAtEnd() throws Exception { - PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX, "One%", PATH_DELIMITER); - - boolean actual = prefixedRegex.isWild(); - - assertThat(actual).isTrue(); - } - - @Test - public void isWildShouldReturnFalseWhenEmptyExpression() throws Exception { - PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX, "", PATH_DELIMITER); - - boolean actual = prefixedRegex.isWild(); - - assertThat(actual).isFalse(); - } - - @Test - public void isWildShouldReturnFalseWhenNullExpression() throws Exception { - PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX, null, PATH_DELIMITER); - - boolean actual = prefixedRegex.isWild(); - - assertThat(actual).isFalse(); - } - - @Test - public void isWildShouldReturnFalseWhenNoWildcard() throws Exception { - PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX, "ONE", PATH_DELIMITER); - - boolean actual = prefixedRegex.isWild(); - - assertThat(actual).isFalse(); - } - - @Test - public void getCombinedNameShouldWork() throws Exception { - PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX, "mailbox", PATH_DELIMITER); - - String actual = prefixedRegex.getCombinedName(); - - assertThat(actual).isEqualTo("name.mailbox"); - } - - @Test - public void getCombinedNameShouldWorkWhenEmptyExpression() throws Exception { - PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX, "", PATH_DELIMITER); - - String actual = prefixedRegex.getCombinedName(); - - assertThat(actual).isEqualTo("name"); - } - - @Test - public void getCombinedNameShouldReturnEmptyStringWhenNullMailboxPathAndExpression() throws Exception { - String prefix = null; - String regex = null; - PrefixedRegex prefixedRegex = new PrefixedRegex(prefix, regex, PATH_DELIMITER); - - String actual = prefixedRegex.getCombinedName(); - - assertThat(actual).isEmpty(); - } - - @Test - public void getCombinedNameShouldIgnoreDelimiterWhenPresentAtBeginningOfExpression() throws Exception { - PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX, ".mailbox", PATH_DELIMITER); - - String actual = prefixedRegex.getCombinedName(); - - assertThat(actual).isEqualTo("name.mailbox"); - } - - @Test - public void getCombinedNameShouldIgnoreDelimiterWhenPresentAtEndOfMailboxName() throws Exception { - PrefixedRegex prefixedRegex = new PrefixedRegex(PREFIX + ".", ".mailbox", PATH_DELIMITER); - - String actual = prefixedRegex.getCombinedName(); - - assertThat(actual).isEqualTo("name.mailbox"); - } - - @Test - public void isExpressionMatchShouldReturnFalseWhenNullExpression() throws Exception { - PrefixedRegex testee = new PrefixedRegex(PREFIX, null, PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("folder"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldMatchFolderWhenMatching() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("mailbox"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldReturnFalseWhenNameBeginsWithDelimiter() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch(".mailbox"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldReturnFalseWhenNameEndsWithDelimiter() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("mailbox."); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldNotMatchFolderWhenNoMatching() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("sub"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldNotMatchFolderWithExpandedEndName() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("mailbox123"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldNotMatchSubFolder() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("mailbox.123"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldReturnTrueWhenEmptyNameAndExpression() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch(""); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldReturnFalseWhenEmptyExpressionAndNameBeginsWithDelimiter() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch(".123"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldNotMatchFolderWhenEmptyExpression() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("folder"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldReturnTrueWhenEmptyNameAndOnlyLocalWildcard() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "%", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch(""); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldReturnTrueWhenOnlyLocalWildcard() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "%", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("folder"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldNotMatchSubFolderWhenOnlyLocalWildcard() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "%", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("mailbox.sub"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldReturnTrueWhenEmptyNameAndOnlyFreeWildcard() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "*", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch(""); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldMatchFolderWhenOnlyFreeWildcard() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "*", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("sub"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldMatchSubFolderWhenOnlyFreeWildcard() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "*", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("mailbox.sub"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldReturnFalseWhenEmptyNameAndLocalWildcardAtEnd() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox%", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch(""); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldReturnFalseWhenLocalWildcardAtEndAndNoMatching() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox%", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("sub"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldMatchFolderWhenLocalWildcardAtEndNotUsed() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox%", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("mailbox"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldReturnTrueWhenLocalWildcardAtEndUsed() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox%", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("mailboxsub"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldNotMatchSubFolderWhenLocalWildcardAtEnd() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox%", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("mailbox.sub"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldReturnFalseWhenEmptyNameAndLocalWildcardAtBeginning() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "%mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch(""); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldNotMatchFolderWhenLocalWildcardAtBeginningAndNoMatching() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "%mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("sub"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldMatchFolderWhenLocalWildcardAtBeginningNotUsed() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "%mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("mailbox"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldMatchFolderWhenLocalWildcardAtBeginningUsed() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "%mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("submailbox"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldNotMatchSubFolderWhenLocalWildcardAtBeginning() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "%mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("sub.mailbox"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldNotMatchDeeplyNestedFolderWhenLocalWildcardAtBeginning() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "%mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("sub.mailbox.sub"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldReturnFalseWhenEmptyNameAndLocalWildcardInMiddle() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch(""); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldReturnFalseWhenLocalWildcardInMiddleAndMissingEndName() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("sub"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldMatchFolderWhenLocalWildcardInMiddleAndMatching() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("submailbox"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldMatchFolderWhenLocalWildcardInMiddle() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("sub123mailbox"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldNotMatchSubFolderWhenLocalWildcardInMiddle() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("sub.mailbox"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldNotMatchSubFolderWhenLocalWildcardInMiddleAndExpandedMiddleName() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("sub.123mailbox"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldReturnFalseWhenLocalWildcardInMiddleAndMissingBeginningName() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("mailbox"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldNotMatchDeeplyNestedFolderWhenLocalWildcardInMiddle() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("subw.hat.eve.rmailbox"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldMatchSubFolderWhenFreeWildcardAtEnd() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox*", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("mailbox.sub"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldReturnFalseWhenEmptyNameAndFreeWildcardAtEnd() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox*", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch(""); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldNotMatchFolderWhenFreeWildcardAtEndAndNoMatching() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox*", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("sub"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldMatchFolderWhenFreeWildcardAtEndNotUsed() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox*", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("mailbox"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldMatchFolderWhenFreeWildcardAtEndUsed() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "mailbox*", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("mailbox123"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldReturnFalseWhenEmptyNameAndFreeWildcardAtBeginning() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "*mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch(""); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldNotMatchFolderWhenFreeWildcardAtBeginningAndNoMatching() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "*mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("sub"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldMatchFolderWhenFreeWildcardAtBeginningNotUsed() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "*mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("mailbox"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldMatchFolderWhenFreeWildcardAtBeginningUsed() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "*mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("submailbox"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldMatchSubFolderWhenFreeWildcardAtBeginning() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "*mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("sub.mailbox"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldReturnFalseWhenEmptyNameAndFreeWildcardInMiddle() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch(""); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldNotMatchFolderWhenFreeWildcardInMiddleAndMissingEndName() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("sub"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldMatchFolderWhenFreeWildcardInMiddleNotUsed() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("submailbox"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldMatchSubFolderWhenFreeWildcardInMiddle() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("sub.mailbox"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldReturnFalseWhenFreeWildcardInMiddleNotUsedAndMissingBeginningName() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("mailbox"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldMatchDeeplyNestedFolderWhenFreeWildcardInMiddle() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("subw.hat.eve.rmailbox"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldReturnFalseWhenEmptyNameAndDoubleFreeWildcardInMiddle() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub**mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch(""); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldReturnFalseWhenDoubleFreeWildcardInMiddleAndMissingEndName() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub**mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("sub"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldReturnTrueWhenDoubleFreeWildcardInMiddleNotUsed() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub**mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("submailbox"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldMatchSubFolderWhenDoubleFreeWildcardInMiddle() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub**mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("sub.mailbox"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldReturnFalseWhenDoubleFreeWildcardInMiddleAndMissingBeginningName() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub**mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("mailbox"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldMatchDeeplyNestedFolderWhenDoubleFreeWildcardInMiddle() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub**mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("subw.hat.eve.rmailbox"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldReturnFalseWhenEmptyNameAndFreeLocalWildcardInMiddle() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*%mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch(""); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldReturnFalseWhenFreeLocalWildcardInMiddleAndMissingEndName() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*%mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("sub"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldMatchFolderWhenFreeLocalWildcardInMiddleNotUsed() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*%mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("submailbox"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldMatchSubFolderWhenFreeLocalWildcardInMiddle() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*%mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("sub.mailbox"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldReturnFalseWhenFreeLocalWildcardInMiddleAndMissingBeginningName() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*%mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("mailbox"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldMatchDeeplyNestedFolderWhenFreeLocalWildcardInMiddle() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*%mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("subw.hat.eve.rmailbox"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldReturnFalseWhenEmptyNameAndLocalFreeWildcardInMiddle() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%*mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch(""); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldNotMatchFolderWhenLocalFreeWildcardInMiddleAndMissingEndName() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%*mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("sub"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldMatchFolderWhenLocalFreewildcardInMiddleNotUsed() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%*mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("submailbox"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldMatchSubFolderWhenLocalFreeWildcardInMiddle() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%*mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("sub.mailbox"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldNotMatchFolderWhenLocalFreeWildcardInMiddleAndMissingBeginningName() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%*mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("mailbox"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldMatchDeeplyNestedFolderWhenLocalFreeWildcardInMiddle() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%*mailbox", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("subw.hat.eve.rmailbox"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldMatchFolderWhenMultipleFreeWildcards() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox*sub**", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("submailboxsub"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldMatchDeeplyNestedFolderWhenMultipleFreeWildcardsNotUsed() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox*sub**", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("sub.mailbox.sub"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldMatchDeeplyNestedFolderWhenMultipleFreeWildcardsUsed() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox*sub**", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("subtosh.boshmailboxtosh.boshsubboshtosh"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldNotMatchDeeplyNestedFolderWhenMultipleFreeWildcardsAndMissingMiddleName() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox*sub**", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("sub.a.sub"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldNotMatchDeeplyNestedFolderWhenMultipleFreeWildcardsAndMissingEndName() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox*sub**", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("sub.a.submailbox.u"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldNotMatchDeeplyNestedFolderWhenMultipleFreeWildcardsAndMissingBeginningdName() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox*sub**", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("utosh.boshmailboxtosh.boshsubasubboshtoshmailboxu"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldMatchFolderWhenMixedLocalFreeWildcardsNotUsed() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%mailbox*sub", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("submailboxsub"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldNotMatchSubFolderWhenMixedLocalFreeWildcards() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub%mailbox*sub", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("sub.mailboxsub"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldMatchFolderWhenMixedFreeLocalWildcardsNotUsed() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox%sub", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("submailboxsub"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldMatchSubFolderWhenMixedFreeLocalWildcards() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox%sub", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("sub.mailboxsub"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldNotMatchSubFolderWhenMixedFreeLocalWildcards() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox%sub", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("submailbox.sub"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldMatchFolderWhenMixedFreeLocalWildcards() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox%sub", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("submailboxwhateversub"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldNotMatchSubFolderEndingWithDelimiterWhenMixedFreeLocalWildcards() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox%sub", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("submailboxsub.Whatever."); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldNotMatchDeeplyNestedFolderWhenMixedFreeLocalWildcards() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox%sub", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("sub.mailboxsub.sub"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldMatchSubFoldeWhenMixedFreeLocalWildcards() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox%sub", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("sub.mailboxsub"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldMatchDeeplyNestedFoldeWhenMixedFreeLocalWildcards() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "sub*mailbox%sub", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("sub.whatever.mailbox123sub"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldNotMatchFolderWhenTwoLocalPathDelimitedWildcards() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "%.%", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("mailbox"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldNotMatchDeeplyNestedFolderWhenTwoLocalPathDelimitedWildcards() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "%.%", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("mailbox.sub.sub"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldMatchSubFolderWhenTwoLocalPathDelimitedWildcards() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "%.%", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("mailbox.sub"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldMatchSubFolderWhenFreeWildcardAndPathDelimiterAtBeginning() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "*.test", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("blah.test"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldNotMatchSubFolderWhenWhenFreeWildcardAndPathDelimiterAtBeginning() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "*.test", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("blah.test3"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldNotMatchDeeplyNestedFolderWhenFreeWildcardAndPathDelimiterAtBeginning() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "*.test", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("blah.test.go"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldIgnoreRegexInjection() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "folder^$!)(%3", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("folder^$!)(123"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldIgnoreRegexInjectionWhenUsingEndOfQuoteAndNoMatching() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "\\Efo.", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("\\Efol"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldIgnoreRegexInjectionWhenUsingEndOfQuoteAndMatching() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "\\Efo.", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("\\Efo."); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldIgnoreRegexInjectionWhenUsingBeginOfQuoteAndNoMatching() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "\\Qfo?", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("\\Qfol"); - - assertThat(actual).isFalse(); - } - - @Test - public void isExpressionMatchShouldIgnoreRegexInjectionWhenUsingBeginOfQuoteAndMatching() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "\\Qfo?", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("\\Qfo?"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldNotEscapeFreeWildcard() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "folder\\*", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("folder\\123"); - - assertThat(actual).isTrue(); - } - - @Test - public void isExpressionMatchShouldNotEscapeLocalWildcard() throws Exception { - PrefixedRegex testee = new PrefixedRegex(EMPTY_PREFIX, "folder\\%", PATH_DELIMITER); - - boolean actual = testee.isExpressionMatch("folder\\123"); - - assertThat(actual).isTrue(); - } -} \ No newline at end of file
http://git-wip-us.apache.org/repos/asf/james-project/blob/0cfb3951/mailbox/api/src/test/java/org/apache/james/mailbox/model/PrefixedWildcardTest.java ---------------------------------------------------------------------- diff --git a/mailbox/api/src/test/java/org/apache/james/mailbox/model/PrefixedWildcardTest.java b/mailbox/api/src/test/java/org/apache/james/mailbox/model/PrefixedWildcardTest.java deleted file mode 100644 index 85af043..0000000 --- a/mailbox/api/src/test/java/org/apache/james/mailbox/model/PrefixedWildcardTest.java +++ /dev/null @@ -1,71 +0,0 @@ -/**************************************************************** - * Licensed to the Apache Software Foundation (ASF) under one * - * or more contributor license agreements. See the NOTICE file * - * distributed with this work for additional information * - * regarding copyright ownership. The ASF licenses this file * - * to you under the Apache License, Version 2.0 (the * - * "License"); you may not use this file except in compliance * - * with the License. You may obtain a copy of the License at * - * * - * http://www.apache.org/licenses/LICENSE-2.0 * - * * - * Unless required by applicable law or agreed to in writing, * - * software distributed under the License is distributed on an * - * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * - * KIND, either express or implied. See the License for the * - * specific language governing permissions and limitations * - * under the License. * - ****************************************************************/ - -package org.apache.james.mailbox.model; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.Assertions.assertThatThrownBy; - -import org.junit.Test; - -public class PrefixedWildcardTest { - public static final String NAME = "toto"; - - @Test - public void constructorShouldThrowOnNullName() { - assertThatThrownBy(() -> new PrefixedWildcard(null)) - .isInstanceOf(NullPointerException.class); - } - - @Test - public void isWildShouldReturnTrue() { - assertThat(new PrefixedWildcard(NAME).isWild()) - .isTrue(); - } - - @Test - public void getCombinedNameShouldReturnName() { - assertThat(new PrefixedWildcard(NAME).getCombinedName()) - .isEqualTo(NAME + MailboxNameExpression.FREEWILDCARD); - } - - @Test - public void isExpressionMatchShouldReturnTrueWhenName() { - assertThat(new PrefixedWildcard(NAME).isExpressionMatch(NAME)) - .isTrue(); - } - - @Test - public void isExpressionMatchShouldReturnTrueWhenNameAndPostfix() { - assertThat(new PrefixedWildcard(NAME).isExpressionMatch(NAME + "any")) - .isTrue(); - } - - @Test - public void isExpressionMatchShouldReturnFalseWhenOtherValue() { - assertThat(new PrefixedWildcard(NAME).isExpressionMatch("other")) - .isFalse(); - } - - @Test - public void isExpressionMatchShouldThrowOnNullValue() { - assertThatThrownBy(() -> new PrefixedWildcard(NAME).isExpressionMatch(null)) - .isInstanceOf(NullPointerException.class); - } -} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/james-project/blob/0cfb3951/mailbox/api/src/test/java/org/apache/james/mailbox/model/WildcardTest.java ---------------------------------------------------------------------- diff --git a/mailbox/api/src/test/java/org/apache/james/mailbox/model/WildcardTest.java b/mailbox/api/src/test/java/org/apache/james/mailbox/model/WildcardTest.java deleted file mode 100644 index 714e73d..0000000 --- a/mailbox/api/src/test/java/org/apache/james/mailbox/model/WildcardTest.java +++ /dev/null @@ -1,59 +0,0 @@ -/**************************************************************** - * Licensed to the Apache Software Foundation (ASF) under one * - * or more contributor license agreements. See the NOTICE file * - * distributed with this work for additional information * - * regarding copyright ownership. The ASF licenses this file * - * to you under the Apache License, Version 2.0 (the * - * "License"); you may not use this file except in compliance * - * with the License. You may obtain a copy of the License at * - * * - * http://www.apache.org/licenses/LICENSE-2.0 * - * * - * Unless required by applicable law or agreed to in writing, * - * software distributed under the License is distributed on an * - * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * - * KIND, either express or implied. See the License for the * - * specific language governing permissions and limitations * - * under the License. * - ****************************************************************/ - -package org.apache.james.mailbox.model; - -import static org.assertj.core.api.Assertions.assertThat; -import static org.assertj.core.api.Assertions.assertThatThrownBy; - -import org.junit.Test; - -public class WildcardTest { - - @Test - public void isWildShouldBeTrue() { - assertThat(new Wildcard().isWild()) - .isTrue(); - } - - @Test - public void getCombinedNameShouldReturnWildcard() { - assertThat(new Wildcard().getCombinedName()) - .isEqualTo(String.valueOf(MailboxNameExpression.FREEWILDCARD)); - } - - @Test - public void isExpressionMatchShouldMatchAnyValue() { - assertThat(new Wildcard().isExpressionMatch("any")) - .isTrue(); - } - - @Test - public void isExpressionMatchShouldMatchEmptyValue() { - assertThat(new Wildcard().isExpressionMatch("")) - .isTrue(); - } - - @Test - public void isExpressionMatchShouldThrowOnNullValue() { - assertThatThrownBy(() -> new Wildcard().isExpressionMatch(null)) - .isInstanceOf(NullPointerException.class); - } - -} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/james-project/blob/0cfb3951/mailbox/api/src/test/java/org/apache/james/mailbox/model/search/ExactNameTest.java ---------------------------------------------------------------------- diff --git a/mailbox/api/src/test/java/org/apache/james/mailbox/model/search/ExactNameTest.java b/mailbox/api/src/test/java/org/apache/james/mailbox/model/search/ExactNameTest.java new file mode 100644 index 0000000..c63bf00 --- /dev/null +++ b/mailbox/api/src/test/java/org/apache/james/mailbox/model/search/ExactNameTest.java @@ -0,0 +1,67 @@ +/**************************************************************** + * Licensed to the Apache Software Foundation (ASF) under one * + * or more contributor license agreements. See the NOTICE file * + * distributed with this work for additional information * + * regarding copyright ownership. The ASF licenses this file * + * to you under the Apache License, Version 2.0 (the * + * "License"); you may not use this file except in compliance * + * with the License. You may obtain a copy of the License at * + * * + * http://www.apache.org/licenses/LICENSE-2.0 * + * * + * Unless required by applicable law or agreed to in writing, * + * software distributed under the License is distributed on an * + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * + * KIND, either express or implied. See the License for the * + * specific language governing permissions and limitations * + * under the License. * + ****************************************************************/ + +package org.apache.james.mailbox.model.search; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.assertj.core.api.Assertions.assertThatThrownBy; + +import org.junit.Test; + +public class ExactNameTest { + + public static final String NAME = "toto"; + + @Test + public void constructorShouldThrowOnNullName() { + assertThatThrownBy(() -> new ExactName(null)) + .isInstanceOf(NullPointerException.class); + } + + @Test + public void isWildShouldReturnFalse() { + assertThat(new ExactName(NAME).isWild()) + .isFalse(); + } + + @Test + public void getCombinedNameShouldReturnName() { + assertThat(new ExactName(NAME).getCombinedName()) + .isEqualTo(NAME); + } + + @Test + public void isExpressionMatchShouldReturnTrueWhenName() { + assertThat(new ExactName(NAME).isExpressionMatch(NAME)) + .isTrue(); + } + + @Test + public void isExpressionMatchShouldReturnFalseWhenOtherValue() { + assertThat(new ExactName(NAME).isExpressionMatch("other")) + .isFalse(); + } + + @Test + public void isExpressionMatchShouldThrowOnNullValue() { + assertThatThrownBy(() -> new ExactName(NAME).isExpressionMatch(null)) + .isInstanceOf(NullPointerException.class); + } + +} \ No newline at end of file http://git-wip-us.apache.org/repos/asf/james-project/blob/0cfb3951/mailbox/api/src/test/java/org/apache/james/mailbox/model/search/MailboxQueryTest.java ---------------------------------------------------------------------- diff --git a/mailbox/api/src/test/java/org/apache/james/mailbox/model/search/MailboxQueryTest.java b/mailbox/api/src/test/java/org/apache/james/mailbox/model/search/MailboxQueryTest.java new file mode 100644 index 0000000..7f59c12 --- /dev/null +++ b/mailbox/api/src/test/java/org/apache/james/mailbox/model/search/MailboxQueryTest.java @@ -0,0 +1,267 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF licenses this file + * to you under the Apache License, Version 2.0 (the + * "License"); you may not use this file except in compliance + * with the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, + * software distributed under the License is distributed on an + * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY + * KIND, either express or implied. See the License for the + * specific language governing permissions and limitations + * under the License. + * + */ + +package org.apache.james.mailbox.model.search; + +import static org.assertj.core.api.Assertions.assertThat; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import org.apache.james.mailbox.MailboxSession; +import org.apache.james.mailbox.MailboxSession.User; +import org.apache.james.mailbox.mock.MockMailboxSession; +import org.apache.james.mailbox.model.MailboxPath; +import org.apache.james.mailbox.model.search.MailboxQuery.Builder; +import org.junit.Before; +import org.junit.Test; + +public class MailboxQueryTest { + private static final String CURRENT_USER = "user"; + + private MailboxPath mailboxPath; + private MailboxSession mailboxSession; + + @Before + public void setUp() { + mailboxPath = new MailboxPath("namespace", "user", "name"); + mailboxSession = new MockMailboxSession("user"); + } + + @Test + public void buildShouldMatchAllValuesWhenMatchesAll() throws Exception { + //When + MailboxQuery actual = MailboxQuery.builder() + .base(mailboxPath) + .matchesAll() + .mailboxSession(mailboxSession) + .build(); + //Then + assertThat(actual.isExpressionMatch("folder")).isTrue(); + } + + @Test + public void buildShouldConstructMailboxPathWhenPrivateUserMailboxes() throws Exception { + //Given + MailboxPath expected = MailboxPath.forUser("user", ""); + //When + MailboxQuery actual = MailboxQuery.builder() + .username("user") + .privateMailboxes() + .mailboxSession(mailboxSession) + .build(); + //Then + assertThat(actual.getNamespace()).contains(expected.getNamespace()); + assertThat(actual.getUser()).contains(expected.getUser()); + assertThat(actual.getBaseName()).contains(expected.getName()); + } + + @Test + public void buildShouldMatchAllValuesWhenPrivateUserMailboxes() throws Exception { + //Given + Builder testee = MailboxQuery.builder() + .username("user") + .privateMailboxes() + .mailboxSession(mailboxSession); + //When + MailboxQuery actual = testee.build(); + //Then + assertThat(actual.isExpressionMatch("folder")).isTrue(); + } + + @Test + public void builderShouldInitFromSessionWhenGiven() throws Exception { + //Given + MailboxSession mailboxSession = mock(MailboxSession.class); + when(mailboxSession.getPathDelimiter()).thenReturn('#'); + User user = mock(User.class); + when(user.getUserName()).thenReturn("little bobby table"); + when(mailboxSession.getUser()).thenReturn(user); + // When + Builder query = MailboxQuery.privateMailboxesBuilder(mailboxSession); + //Then + assertThat(query.pathDelimiter).contains('#'); + assertThat(query.username).contains("little bobby table"); + } + + @Test + public void builderShouldNotThrowWhenNoBaseDefined() throws Exception { + //Given + Builder testee = MailboxQuery.builder() + .expression("abc") + .mailboxSession(mailboxSession); + //When + testee.build(); + } + + @Test(expected=IllegalStateException.class) + public void builderShouldThrowWhenBaseAndUsernameGiven() throws Exception { + //Given + Builder testee = MailboxQuery.builder() + .base(mailboxPath) + .username("user"); + //When + testee.build(); + } + + @Test(expected=IllegalStateException.class) + public void builderShouldThrowWhenBaseGiven() throws Exception { + //Given + Builder testee = MailboxQuery.builder() + .base(mailboxPath) + .privateMailboxes(); + //When + testee.build(); + } + + @Test(expected=IllegalStateException.class) + public void builderShouldThrowWhenMissingUsername() throws Exception { + //Given + Builder testee = MailboxQuery.builder() + .privateMailboxes(); + //When + testee.build(); + } + + @Test + public void builderShouldUseBaseWhenGiven() throws Exception { + //When + MailboxQuery actual = MailboxQuery.builder() + .base(mailboxPath) + .mailboxSession(mailboxSession) + .build(); + //Then + assertThat(actual.getNamespace()).contains(mailboxPath.getNamespace()); + assertThat(actual.getUser()).contains(mailboxPath.getUser()); + assertThat(actual.getBaseName()).contains(mailboxPath.getName()); + } + + @Test + public void belongsToNamespaceAndUserShouldReturnTrueWithIdenticalMailboxes() { + MailboxQuery mailboxQuery = MailboxQuery.builder() + .base(mailboxPath) + .mailboxSession(mailboxSession) + .build(); + + assertThat(mailboxQuery.belongsToRequestedNamespaceAndUser(mailboxPath)) + .isTrue(); + } + + @Test + public void belongsToNamespaceAndUserShouldReturnTrueWithIdenticalMailboxesWithNullUser() { + MailboxPath base = new MailboxPath("namespace", null, "name"); + + MailboxQuery mailboxQuery = MailboxQuery.builder() + .base(base) + .mailboxSession(mailboxSession) + .build(); + + assertThat(mailboxQuery.belongsToRequestedNamespaceAndUser(mailboxPath)) + .isTrue(); + } + + @Test + public void belongsToNamespaceAndUserShouldReturnTrueWithIdenticalMailboxesWithNullNamespace() { + MailboxPath mailboxPath = new MailboxPath(null, "user", "name"); + + MailboxQuery mailboxQuery = MailboxQuery.builder() + .base(mailboxPath) + .mailboxSession(mailboxSession) + .build(); + + assertThat(mailboxQuery.belongsToRequestedNamespaceAndUser(mailboxPath)) + .isTrue(); + } + + @Test + public void belongsToNamespaceAndUserShouldReturnTrueWithMailboxWithSameNamespaceAndUserWithNullUser() { + MailboxQuery mailboxQuery = MailboxQuery.builder() + .base(new MailboxPath("namespace", null, "name")) + .mailboxSession(mailboxSession) + .build(); + + assertThat(mailboxQuery.belongsToRequestedNamespaceAndUser(new MailboxPath("namespace", null, "name"))) + .isTrue(); + } + + @Test + public void belongsToNamespaceAndUserShouldReturnTrueWithMailboxWithSameNamespaceAndUser() { + MailboxQuery mailboxQuery = MailboxQuery.builder() + .base(new MailboxPath("namespace", CURRENT_USER, "name")) + .mailboxSession(mailboxSession) + .build(); + + assertThat(mailboxQuery.belongsToRequestedNamespaceAndUser(new MailboxPath("namespace", CURRENT_USER, "name2"))) + .isTrue(); + } + + @Test + public void belongsToNamespaceAndUserShouldReturnFalseWithDifferentNamespace() { + MailboxQuery mailboxQuery = MailboxQuery.builder() + .base(new MailboxPath("namespace", CURRENT_USER, "name")) + .mailboxSession(mailboxSession) + .build(); + + assertThat(mailboxQuery.belongsToRequestedNamespaceAndUser(new MailboxPath("namespace2", CURRENT_USER, "name"))) + .isFalse(); + } + + @Test + public void belongsToNamespaceAndUserShouldReturnFalseWithDifferentUser() { + MailboxQuery mailboxQuery = MailboxQuery.builder() + .base(new MailboxPath("namespace", CURRENT_USER, "name")) + .mailboxSession(mailboxSession) + .build(); + + assertThat(mailboxQuery.belongsToRequestedNamespaceAndUser(new MailboxPath("namespace", CURRENT_USER + "2", "name"))) + .isFalse(); + } + @Test + public void belongsToNamespaceAndUserShouldReturnFalseWithOneOfTheUserNull() { + MailboxQuery mailboxQuery = MailboxQuery.builder() + .base(new MailboxPath("namespace", CURRENT_USER, "name")) + .mailboxSession(mailboxSession) + .build(); + + assertThat(mailboxQuery.belongsToRequestedNamespaceAndUser(new MailboxPath("namespace", null, "name"))) + .isFalse(); + } + + @Test + public void belongsToNamespaceAndUserShouldReturnFalseWhenDifferentUser() { + MailboxQuery mailboxQuery = MailboxQuery.builder() + .base(new MailboxPath("namespace", CURRENT_USER, "name")) + .mailboxSession(mailboxSession) + .build(); + + assertThat(mailboxQuery.belongsToRequestedNamespaceAndUser(new MailboxPath("namespace", "other", "name"))) + .isFalse(); + } + + @Test + public void belongsToNamespaceAndUserShouldReturnFalseIfNamespaceAreDifferentWithNullUser() { + MailboxQuery mailboxQuery = MailboxQuery.builder() + .base(new MailboxPath("namespace", null, "name")) + .mailboxSession(mailboxSession) + .build(); + + assertThat(mailboxQuery.belongsToRequestedNamespaceAndUser(new MailboxPath("namespace2", null, "name"))) + .isFalse(); + } +} --------------------------------------------------------------------- To unsubscribe, e-mail: server-dev-unsubscr...@james.apache.org For additional commands, e-mail: server-dev-h...@james.apache.org
