Merge pull request #268 from seaswalker/avoid_conflict_with_spring
[SHIRO-804] - Avoid conflicts with spring boot aop
diff --git a/.github/workflows/maven.yml b/.github/workflows/maven.yml
new file mode 100644
index 0000000..a5be92a
--- /dev/null
+++ b/.github/workflows/maven.yml
@@ -0,0 +1,57 @@
+# 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.
+
+name: Java CI
+
+on: [ push, pull_request ]
+
+jobs:
+ build:
+
+ strategy:
+ matrix:
+ os: [ ubuntu-latest, windows-latest, macOS-latest ]
+ java: [ 8, 11, 15, 16-ea ]
+ fail-fast: false
+
+ runs-on: ${{ matrix.os }}
+
+ steps:
+ - name: Checkout
+ uses: actions/checkout@v2
+
+ - name: Set up cache for ~./m2/repository
+ uses: actions/cache@v2.1.3
+ with:
+ path: ~/.m2/repository
+ key: maven-${{ matrix.os }}-java${{ matrix.java }}-${{ hashFiles('**/pom.xml') }}
+ restore-keys: |
+ maven-${{ matrix.os }}-java${{ matrix.java }}-
+ maven-${{ matrix.os }}-
+
+ - name: Set up JDK
+ uses: actions/setup-java@v1
+ with:
+ java-version: ${{ matrix.java }}
+
+ - name: License Check
+ run: mvn apache-rat:check "-Drat.consoleOutput"
+
+ - name: Build with Maven
+ run: mvn verify --errors --batch-mode --no-transfer-progress -Pdocs
+
+
diff --git a/.jenkins.groovy b/.jenkins.groovy
new file mode 100644
index 0000000..1ccd3a0
--- /dev/null
+++ b/.jenkins.groovy
@@ -0,0 +1,186 @@
+/*
+ * 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.
+ */
+
+def deployableBranch = env.BRANCH_NAME ==~ /(1.7.x|1.8.x|main)/
+
+pipeline {
+
+ agent none
+
+ options {
+ // When we have test-fails e.g. we don't need to run the remaining steps
+ skipStagesAfterUnstable()
+ buildDiscarder(logRotator(numToKeepStr: '5', artifactNumToKeepStr: '5'))
+ }
+
+ stages {
+ stage('Build') {
+ matrix {
+ axes {
+ axis {
+ // https://cwiki.apache.org/confluence/display/INFRA/JDK+Installation+Matrix
+ name 'MATRIX_JDK'
+ values 'jdk_1.8_latest', 'adopt_hs_8_latest', 'adopt_j9_8_latest',
+ 'jdk_11_latest', 'adopt_hs_11_latest', 'adopt_j9_11_latest',
+ 'jdk_15_latest', 'adopt_hs_15_latest', 'adopt_j9_15_latest'
+ }
+ // Additional axess, like OS and maven version can be configured here.
+ }
+
+ agent {
+ node {
+ // https://cwiki.apache.org/confluence/display/INFRA/ci-builds.apache.org
+ label 'ubuntu'
+ }
+ }
+
+ options {
+ // Configure an overall timeout for the build of one hour.
+ timeout(time: 1, unit: 'HOURS')
+ }
+
+ tools {
+ // https://cwiki.apache.org/confluence/display/INFRA/Maven+Installation+Matrix
+ maven 'maven_3_latest'
+ jdk "${MATRIX_JDK}"
+ }
+
+ stages {
+ stage('Initialization') {
+ steps {
+ echo 'Building Branch: ' + env.BRANCH_NAME
+ echo 'Using PATH = ' + env.PATH
+ }
+ }
+
+ stage('Cleanup') {
+ steps {
+ echo 'Cleaning up the workspace'
+ cleanWs()
+ }
+ }
+
+ stage('Checkout') {
+ steps {
+ echo 'Checking out branch ' + env.BRANCH_NAME
+ checkout scm
+ }
+ }
+
+ stage('License check') {
+ steps {
+ echo 'License check'
+ sh 'mvn --batch-mode -Drat.consoleOutput=true apache-rat:check'
+ }
+ }
+
+ stage('Build') {
+ steps {
+ echo 'Building'
+ sh 'mvn --update-snapshots --batch-mode --errors clean verify -Pdocs -Dmaven.test.failure.ignore=true'
+ }
+ post {
+ always {
+ junit(testResults: '**/surefire-reports/*.xml', allowEmptyResults: true)
+ junit(testResults: '**/failsafe-reports/*.xml', allowEmptyResults: true)
+ }
+ }
+ }
+
+ stage('Deploy') {
+ when {
+ allOf {
+ expression { deployableBranch }
+ expression { MATRIX_JDK == 'jdk_11_latest' }
+ // is not a PR (GitHub) / MergeRequest (GitLab) / Change (Gerrit)?
+ not { changeRequest() }
+ }
+ }
+ steps {
+ echo 'Deploying'
+ sh 'mvn --batch-mode clean deploy -Pdocs -DskipTests'
+ }
+ }
+
+ } // end of stages
+
+ // Do any post build stuff ... such as sending emails depending on the overall build result.
+ post {
+ // If this build failed, send an email to the list.
+ failure {
+ script {
+ if (deployableBranch) {
+ emailext(
+ subject: "[BUILD-FAILURE]: Job '${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]'",
+ body: """
+BUILD-FAILURE: Job '${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]':
+Check console output at "<a href="${env.BUILD_URL}">${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]</a>"
+""",
+ to: "dev@shiro.apache.org",
+ recipientProviders: [[$class: 'DevelopersRecipientProvider']]
+ )
+ }
+ }
+ }
+
+ // If this build didn't fail, but there were failing tests, send an email to the list.
+ unstable {
+ script {
+ if (deployableBranch) {
+ emailext(
+ subject: "[BUILD-UNSTABLE]: Job '${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]'",
+ body: """
+BUILD-UNSTABLE: Job '${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]':
+Check console output at "<a href="${env.BUILD_URL}">${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]</a>"
+""",
+ to: "dev@shiro.apache.org",
+ recipientProviders: [[$class: 'DevelopersRecipientProvider']]
+ )
+ }
+ }
+ }
+
+ // Send an email, if the last build was not successful and this one is.
+ success {
+ // Cleanup the build directory if the build was successful
+ // (in this cae we probably don't have to do any post-build analysis)
+ cleanWs()
+ script {
+ if (deployableBranch
+ && (currentBuild.previousBuild != null) && (currentBuild.previousBuild.result != 'SUCCESS')) {
+ emailext(
+ subject: "[BUILD-STABLE]: Job '${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]'",
+ body: """
+BUILD-STABLE: Job '${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]':
+Is back to normal.
+""",
+ to: "dev@shiro.apache.org",
+ recipientProviders: [[$class: 'DevelopersRecipientProvider']]
+ )
+ }
+ }
+ }
+ } // end of post
+
+ } // end of matrix
+
+ } // main stage ('Build')
+
+ } // main stages
+}
diff --git a/.travis.yml b/.travis.yml
deleted file mode 100644
index ad74997..0000000
--- a/.travis.yml
+++ /dev/null
@@ -1,93 +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.
-
-language: java
-
-env:
- global:
- - JABBA_HOME=$HOME/.jabba
- # RI binaries are the Oracle reference implementation
- - DEFAULT_JDK=adopt@1.8.0-252
-
-cache:
- directories:
- - "$HOME/.m2"
- - "$HOME/.jabba"
-
-jobs:
- include:
- # JDK 8 builds (LTS)
- - os: linux
- env:
- - TRAVIS_JDK=$DEFAULT_JDK
- - os: linux
- env:
- - TRAVIS_JDK=adopt-openj9@1.8.0-252
- - os: linux
- env:
- - TRAVIS_JDK=amazon-corretto@1.8.252-09.1
- - os: linux
- env:
- - TRAVIS_JDK=liberica@1.8.252-9
- - os: linux
- env:
- - TRAVIS_JDK=zulu@1.8.252
- # JDK 11 builds (LTS)
- - os: linux
- env:
- - TRAVIS_JDK=adopt@1.11.0-6
- - os: linux
- env:
- - TRAVIS_JDK=adopt-openj9@1.11.0-6
- - os: linux
- env:
- - TRAVIS_JDK=amazon-corretto@1.11.0-6.10.1
- - os: linux
- env:
- - TRAVIS_JDK=zulu@1.11.0-6
- # JDK 14 builds (latest)
- - os: linux
- env:
- - TRAVIS_JDK=adopt@1.14.0-0
- - os: linux
- env:
- - TRAVIS_JDK=adopt-openj9@1.14.0-0
- - os: linux
- env:
- - TRAVIS_JDK=openjdk@1.14.0
-
-before_cache:
- - rm -rf "$HOME/.m2/repository/org/apache/shiro"
-
-before_install:
- - if [ "$TRAVIS_OS_NAME" == "linux" ]; then curl -sL https://github.com/shyiko/jabba/raw/master/install.sh | bash && . $JABBA_HOME/jabba.sh; fi
- - if [ "$TRAVIS_OS_NAME" == "osx" ]; then curl -sL https://github.com/shyiko/jabba/raw/master/install.sh | bash && . $JABBA_HOME/jabba.sh; fi
-
-install:
- - if [ "$TRAVIS_OS_NAME" == "linux" ]; then $JABBA_HOME/bin/jabba install $TRAVIS_JDK; jabba use $TRAVIS_JDK; fi
- - if [ "$TRAVIS_OS_NAME" == "osx" ]; then $JABBA_HOME/bin/jabba install $TRAVIS_JDK; jabba use $TRAVIS_JDK; fi
- - java -version
-
-script:
-- "mvn -e -Pdocs install apache-rat:check -B -Dorg.slf4j.simpleLogger.log.org.apache.maven.cli.transfer.Slf4jMavenTransferListener=warn"
-
-after_success:
- # do a coverage analyses for each PR or branch, but only once for each build matrix.
- - |
- if [ "$TRAVIS_JDK" == "$DEFAULT_JDK" ]; then
- bash <(curl -s https://codecov.io/bash) -f test-coverage/target/site/jacoco-aggregate/jacoco.xml
- fi
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 3c4052e..3953cf3 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -13,7 +13,10 @@
In your browser, navigate to: [https://github.com/apache/shiro](https://github.com/apache/shiro)
-Fork the repository by clicking on the 'Fork' button on the top right hand side. The fork will happen and you will be taken to your own fork of the repository. Copy the Git repository URL by clicking on the clipboard next to the URL on the right hand side of the page under '**HTTPS** clone URL'. You will paste this URL when doing the following `git clone` command.
+Fork the repository by clicking on the 'Fork' button on the top right hand side.
+The fork will happen and you will be taken to your own fork of the repository.
+Copy the Git repository URL by clicking on the clipboard next to the URL on the right hand side of the page under '**HTTPS** clone URL'.
+You will paste this URL when doing the following `git clone` command.
On your computer, follow these steps to setup a local repository for working on Apache Shiro:
@@ -21,16 +24,18 @@
$ git clone https://github.com/YOUR_ACCOUNT/shiro.git
$ cd shiro
$ git remote add upstream https://github.com/apache/shiro.git
-$ git checkout master
+$ git checkout main
$ git fetch upstream
-$ git rebase upstream/master
+$ git rebase upstream/main
```
Making changes
--------------
-It is important that you create a new branch to make changes on and that you do not change the `master` branch (other than to rebase in changes from `upstream/master`). In this example I will assume you will be making your changes to a branch called `feature_x`. This `feature_x` branch will be created on your local repository and will be pushed to your forked repository on GitHub. Once this branch is on your fork you will create a Pull Request for the changes to be added to the Apache Shiro project.
+It is important that you create a new branch to make changes on and that you do not change the `main` branch (other than to rebase in changes from `upstream/main`).
+In this example I will assume you will be making your changes to a branch called `feature_x`. This `feature_x` branch will be created on your local repository and
+will be pushed to your forked repository on GitHub. Once this branch is on your fork you will create a Pull Request for the changes to be added to the Apache Shiro project.
It is best practice to create a new branch each time you want to contribute to the project and only track the changes for that pull request in this branch.
@@ -42,40 +47,44 @@
$ git commit -a -m "descriptive commit message for your changes"
```
-> The `-b` specifies that you want to create a new branch called `feature_x`. You only specify `-b` the first time you checkout because you are creating a new branch. Once the `feature_x` branch exists, you can later switch to it with only `git checkout feature_x`.
+> The `-b` specifies that you want to create a new branch called `feature_x`. You only specify `-b` the first time you checkout because you are creating a new branch.
+> Once the `feature_x` branch exists, you can later switch to it with only `git checkout feature_x`.
-Rebase `feature_x` to include updates from `upstream/master`
+Rebase `feature_x` to include updates from `upstream/main`
------------------------------------------------------------
-It is important that you maintain an up-to-date `master` branch in your local repository. This is done by rebasing in the code changes from `upstream/master` (the official Apache Shiro project repository) into your local repository. You will want to do this before you start working on a feature as well as right before you submit your changes as a pull request. I recommend you do this process periodically while you work to make sure you are working off the most recent project code.
+It is important that you maintain an up-to-date `main` branch in your local repository. This is done by rebasing in the code changes from `upstream/main`
+(the official Apache Shiro project repository) into your local repository. You will want to do this before you start working on a feature as well as right
+before you submit your changes as a pull request. I recommend you do this process periodically while you work to make sure you are working off the most recent project code.
This process will do the following:
-1. Checkout your local `master` branch
-2. Synchronize your local `master` branch with the `upstream/master` so you have all the latest changes from the project
+1. Checkout your local `main` branch
+2. Synchronize your local `main` branch with the `upstream/main` so you have all the latest changes from the project
3. Rebase the latest project code into your `feature_x` branch so it is up-to-date with the upstream code
``` bash
-$ git checkout master
+$ git checkout main
$ git fetch upstream
-$ git rebase upstream/master
+$ git rebase upstream/main
$ git checkout feature_x
-$ git rebase master
+$ git rebase main
```
-> Now your `feature_x` branch is up-to-date with all the code in `upstream/master`.
+> Now your `feature_x` branch is up-to-date with all the code in `upstream/main`.
Make a GitHub Pull Request to contribute your changes
-----------------------------------------------------
-When you are happy with your changes and you are ready to contribute them, you will create a Pull Request on GitHub to do so. This is done by pushing your local changes to your forked repository (default remote name is `origin`) and then initiating a pull request on GitHub.
+When you are happy with your changes and you are ready to contribute them, you will create a Pull Request on GitHub to do so. This is done by pushing your local changes
+to your forked repository (default remote name is `origin`) and then initiating a pull request on GitHub.
-> **IMPORTANT:** Make sure you have rebased your `feature_x` branch to include the latest code from `upstream/master` _before_ you do this.
+> **IMPORTANT:** Make sure you have rebased your `feature_x` branch to include the latest code from `upstream/main` _before_ you do this.
``` bash
-$ git push origin master
+$ git push origin main
$ git push origin feature_x
```
@@ -85,23 +94,25 @@
1. In your browser, navigate to your forked repository: [https://github.com/YOUR_ACCOUNT/shiro](https://github.com/YOUR_ACCOUNT/shiro)
2. Click the new button called '**Compare & pull request**' that showed up just above the main area in your forked repository
-3. Validate the pull request will be into the upstream `master` and will be from your `feature_x` branch
+3. Validate the pull request will be into the upstream `main` and will be from your `feature_x` branch
4. Enter a detailed description of the work you have done and then click '**Send pull request**'
-If you are requested to make modifications to your proposed changes, make the changes locally on your `feature_x` branch, re-push the `feature_x` branch to your fork. The existing pull request should automatically pick up the change and update accordingly.
+If you are requested to make modifications to your proposed changes, make the changes locally on your `feature_x` branch, re-push the `feature_x` branch to your fork.
+The existing pull request should automatically pick up the change and update accordingly.
Cleaning up after a successful pull request
-------------------------------------------
-Once the `feature_x` branch has been committed into the `upstream/master` branch, your local `feature_x` branch and the `origin/feature_x` branch are no longer needed. If you want to make additional changes, restart the process with a new branch.
+Once the `feature_x` branch has been committed into the `upstream/main` branch, your local `feature_x` branch and the `origin/feature_x` branch are no longer needed.
+If you want to make additional changes, restart the process with a new branch.
-> **IMPORTANT:** Make sure that your changes are in `upstream/master` before you delete your `feature_x` and `origin/feature_x` branches!
+> **IMPORTANT:** Make sure that your changes are in `upstream/main` before you delete your `feature_x` and `origin/feature_x` branches!
You can delete these deprecated branches with the following:
``` bash
-$ git checkout master
+$ git checkout main
$ git branch -D feature_x
$ git push origin :feature_x
```
diff --git a/Jenkinsfile b/Jenkinsfile
deleted file mode 100644
index 410c09b..0000000
--- a/Jenkinsfile
+++ /dev/null
@@ -1,173 +0,0 @@
-#!groovy
-
-/*
- *
- * 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.
- *
- */
-pipeline {
-
- agent {
- node {
- label 'ubuntu'
- }
- }
-
- environment {
- // ... setup any environment variables ...
- MVN_LOCAL_REPO_OPT = '-Dmaven.repo.local=.repository'
- MVN_TEST_FAIL_IGNORE = '-Dmaven.test.failure.ignore=true'
- }
-
- tools {
- // ... tell Jenkins what java version, maven version or other tools are required ...
- maven 'maven_3_latest'
- jdk 'jdk_1.8_latest'
- }
-
- options {
- // Configure an overall timeout for the build of one hour.
- timeout(time: 1, unit: 'HOURS')
- // When we have test-fails e.g. we don't need to run the remaining steps
- skipStagesAfterUnstable()
- buildDiscarder(logRotator(numToKeepStr: '5', artifactNumToKeepStr: '5'))
- }
-
- stages {
- stage('Initialization') {
- steps {
- echo 'Building Branch: ' + env.BRANCH_NAME
- echo 'Using PATH = ' + env.PATH
- }
- }
-
- stage('Cleanup') {
- steps {
- echo 'Cleaning up the workspace'
- deleteDir()
- }
- }
-
- stage('Checkout') {
- steps {
- echo 'Checking out branch ' + env.BRANCH_NAME
- checkout scm
- }
- }
-
- stage('Build') {
- steps {
- echo 'Building'
- sh 'mvn -U -B -e clean install -DskipTests apache-rat:check'
- }
- }
-
- stage('Tests') {
- steps {
- echo 'Running tests'
- sh 'mvn test'
- }
- post {
- always {
- junit(testResults: '**/surefire-reports/*.xml', allowEmptyResults: true)
- junit(testResults: '**/failsafe-reports/*.xml', allowEmptyResults: true)
- }
- }
- }
-
- stage('Generate doc') {
- when {
- expression {
- env.BRANCH_NAME ==~ /(1.5.x|1.6.x|master)/
- }
- }
- steps {
- echo 'Generate documentation'
- sh 'mvn javadoc:aggregate source:aggregate -Pdocs'
- }
- }
-
- stage('Deploy') {
- when {
- expression {
- env.BRANCH_NAME ==~ /(1.5.x|1.6.x|master)/
- }
- }
- steps {
- echo 'Deploying'
- sh 'mvn deploy'
- }
- }
- }
-
- // Do any post build stuff ... such as sending emails depending on the overall build result.
- post {
- // If this build failed, send an email to the list.
- failure {
- script {
- if(env.BRANCH_NAME == "1.5.x" || env.BRANCH_NAME == "1.6.x" || env.BRANCH_NAME == "master") {
- emailext(
- subject: "[BUILD-FAILURE]: Job '${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]'",
- body: """
-BUILD-FAILURE: Job '${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]':
-Check console output at "<a href="${env.BUILD_URL}">${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]</a>"
-""",
- to: "dev@shiro.apache.org",
- recipientProviders: [[$class: 'DevelopersRecipientProvider']]
- )
- }
- }
- }
-
- // If this build didn't fail, but there were failing tests, send an email to the list.
- unstable {
- script {
- if(env.BRANCH_NAME == "1.5.x" || env.BRANCH_NAME == "1.6.x" || env.BRANCH_NAME == "master") {
- emailext(
- subject: "[BUILD-UNSTABLE]: Job '${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]'",
- body: """
-BUILD-UNSTABLE: Job '${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]':
-Check console output at "<a href="${env.BUILD_URL}">${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]</a>"
-""",
- to: "dev@shiro.apache.org",
- recipientProviders: [[$class: 'DevelopersRecipientProvider']]
- )
- }
- }
- }
-
- // Send an email, if the last build was not successful and this one is.
- success {
- // Cleanup the build directory if the build was successful
- // (in this cae we probably don't have to do any post-build analysis)
- deleteDir()
- script {
- if ((env.BRANCH_NAME == "1.5.x" || env.BRANCH_NAME == "1.6.x" || env.BRANCH_NAME == "master") && (currentBuild.previousBuild != null) && (currentBuild.previousBuild.result != 'SUCCESS')) {
- emailext (
- subject: "[BUILD-STABLE]: Job '${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]'",
- body: """
-BUILD-STABLE: Job '${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]':
-Is back to normal.
-""",
- to: "dev@shiro.apache.org",
- recipientProviders: [[$class: 'DevelopersRecipientProvider']]
- )
- }
- }
- }
- }
-
-}
\ No newline at end of file
diff --git a/Jenkinsfile-jdk11 b/Jenkinsfile-jdk11
deleted file mode 100644
index d10f476..0000000
--- a/Jenkinsfile-jdk11
+++ /dev/null
@@ -1,171 +0,0 @@
-#!groovy
-
-/*
- *
- * 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.
- *
- */
-
-pipeline {
-
- agent {
- node {
- label 'ubuntu'
- }
- }
-
- environment {
- // ... setup any environment variables ...
- MVN_LOCAL_REPO_OPT = '-Dmaven.repo.local=.repository'
- MVN_TEST_FAIL_IGNORE = '-Dmaven.test.failure.ignore=true'
- }
-
- tools {
- // ... tell Jenkins what java version, maven version or other tools are required ...
- maven 'maven_3_latest'
- jdk 'jdk_11_latest'
- }
-
- options {
- // Configure an overall timeout for the build of one hour.
- timeout(time: 1, unit: 'HOURS')
- // When we have test-fails e.g. we don't need to run the remaining steps
- skipStagesAfterUnstable()
- buildDiscarder(logRotator(numToKeepStr: '5', artifactNumToKeepStr: '5'))
- }
-
- stages {
- stage('Initialization') {
- steps {
- echo 'Building Branch: ' + env.BRANCH_NAME
- echo 'Using PATH = ' + env.PATH
- }
- }
-
- stage('Cleanup') {
- steps {
- echo 'Cleaning up the workspace'
- deleteDir()
- }
- }
-
- stage('Checkout') {
- steps {
- echo 'Checking out branch ' + env.BRANCH_NAME
- checkout scm
- }
- }
-
- stage('Build') {
- steps {
- echo 'Building'
- sh 'mvn -U -B -e clean install -DskipTests apache-rat:check'
- }
- }
-
- stage('Tests') {
- steps {
- echo 'Running tests'
- sh 'mvn test'
- }
- post {
- always {
- junit(testResults: '**/surefire-reports/*.xml', allowEmptyResults: true)
- junit(testResults: '**/failsafe-reports/*.xml', allowEmptyResults: true)
- }
- }
- }
-
- stage('Code Quality') {
- steps {
- echo 'Checking Code Quality on SonarCloud'
- withCredentials([string(credentialsId: 'sonarcloud-key-apache-shiro', variable: 'SONAR_TOKEN')]) {
- sh 'mvn sonar:sonar -Dsonar.host.url=https://sonarcloud.io -Dsonar.organization=apache -Dsonar.projectKey=apache_shiro -Dsonar.branch.name=${BRANCH_NAME} -Dsonar.login=${SONAR_TOKEN}'
- }
- }
- }
-
- stage('Generate doc') {
- when {
- expression {
- env.BRANCH_NAME ==~ /(1.5.x|1.6.x|master)/
- }
- }
- steps {
- echo 'Generate documentation'
- sh 'mvn javadoc:aggregate source:aggregate -Pdocs'
- }
- }
- }
-
- // Do any post build stuff ... such as sending emails depending on the overall build result.
- post {
- // If this build failed, send an email to the list.
- failure {
- script {
- if(env.BRANCH_NAME == "1.5.x" || env.BRANCH_NAME == "1.6.x" || env.BRANCH_NAME == "master") {
- emailext(
- subject: "[BUILD-FAILURE]: Job '${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]'",
- body: """
-BUILD-FAILURE: Job '${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]':
-Check console output at "<a href="${env.BUILD_URL}">${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]</a>"
-""",
- to: "dev@shiro.apache.org",
- recipientProviders: [[$class: 'DevelopersRecipientProvider']]
- )
- }
- }
- }
-
- // If this build didn't fail, but there were failing tests, send an email to the list.
- unstable {
- script {
- if(env.BRANCH_NAME == "1.5.x" || env.BRANCH_NAME == "1.6.x" || env.BRANCH_NAME == "master") {
- emailext(
- subject: "[BUILD-UNSTABLE]: Job '${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]'",
- body: """
-BUILD-UNSTABLE: Job '${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]':
-Check console output at "<a href="${env.BUILD_URL}">${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]</a>"
-""",
- to: "dev@shiro.apache.org",
- recipientProviders: [[$class: 'DevelopersRecipientProvider']]
- )
- }
- }
- }
-
- // Send an email, if the last build was not successful and this one is.
- success {
- // Cleanup the build directory if the build was successful
- // (in this cae we probably don't have to do any post-build analysis)
- deleteDir()
- script {
- if ((env.BRANCH_NAME == "1.5.x" || env.BRANCH_NAME == "1.6.x" || env.BRANCH_NAME == "master") && (currentBuild.previousBuild != null) && (currentBuild.previousBuild.result != 'SUCCESS')) {
- emailext (
- subject: "[BUILD-STABLE]: Job '${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]'",
- body: """
-BUILD-STABLE: Job '${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]':
-Is back to normal.
-""",
- to: "dev@shiro.apache.org",
- recipientProviders: [[$class: 'DevelopersRecipientProvider']]
- )
- }
- }
- }
- }
-
-}
\ No newline at end of file
diff --git a/Jenkinsfile-jdk14 b/Jenkinsfile-jdk14
deleted file mode 100644
index 7fcda4d..0000000
--- a/Jenkinsfile-jdk14
+++ /dev/null
@@ -1,162 +0,0 @@
-#!groovy
-
-/*
- *
- * 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.
- *
- */
-
-pipeline {
-
- agent {
- node {
- label 'ubuntu'
- }
- }
-
- environment {
- // ... setup any environment variables ...
- MVN_LOCAL_REPO_OPT = '-Dmaven.repo.local=.repository'
- MVN_TEST_FAIL_IGNORE = '-Dmaven.test.failure.ignore=true'
- }
-
- tools {
- // ... tell Jenkins what java version, maven version or other tools are required ...
- maven 'maven_3_latest'
- jdk 'jdk_14_latest'
- }
-
- options {
- // Configure an overall timeout for the build of one hour.
- timeout(time: 1, unit: 'HOURS')
- // When we have test-fails e.g. we don't need to run the remaining steps
- skipStagesAfterUnstable()
- buildDiscarder(logRotator(numToKeepStr: '5', artifactNumToKeepStr: '5'))
- }
-
- stages {
- stage('Initialization') {
- steps {
- echo 'Building Branch: ' + env.BRANCH_NAME
- echo 'Using PATH = ' + env.PATH
- }
- }
-
- stage('Cleanup') {
- steps {
- echo 'Cleaning up the workspace'
- deleteDir()
- }
- }
-
- stage('Checkout') {
- steps {
- echo 'Checking out branch ' + env.BRANCH_NAME
- checkout scm
- }
- }
-
- stage('Build') {
- steps {
- echo 'Building'
- sh 'mvn -U -B -e clean install -DskipTests apache-rat:check'
- }
- }
-
- stage('Tests') {
- steps {
- echo 'Running tests'
- sh 'mvn test'
- }
- post {
- always {
- junit(testResults: '**/surefire-reports/*.xml', allowEmptyResults: true)
- junit(testResults: '**/failsafe-reports/*.xml', allowEmptyResults: true)
- }
- }
- }
-
- stage('Generate doc') {
- when {
- expression {
- env.BRANCH_NAME ==~ /(1.5.x|1.6.x|master)/
- }
- }
- steps {
- echo 'Generate documentation'
- sh 'mvn javadoc:aggregate source:aggregate -Pdocs'
- }
- }
- }
-
- // Do any post build stuff ... such as sending emails depending on the overall build result.
- post {
- // If this build failed, send an email to the list.
- failure {
- script {
- if(env.BRANCH_NAME == "1.5.x" || env.BRANCH_NAME == "1.6.x" || env.BRANCH_NAME == "master") {
- emailext(
- subject: "[BUILD-FAILURE]: Job '${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]'",
- body: """
-BUILD-FAILURE: Job '${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]':
-Check console output at "<a href="${env.BUILD_URL}">${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]</a>"
-""",
- to: "dev@shiro.apache.org",
- recipientProviders: [[$class: 'DevelopersRecipientProvider']]
- )
- }
- }
- }
-
- // If this build didn't fail, but there were failing tests, send an email to the list.
- unstable {
- script {
- if(env.BRANCH_NAME == "1.5.x" || env.BRANCH_NAME == "1.6.x" || env.BRANCH_NAME == "master") {
- emailext(
- subject: "[BUILD-UNSTABLE]: Job '${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]'",
- body: """
-BUILD-UNSTABLE: Job '${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]':
-Check console output at "<a href="${env.BUILD_URL}">${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]</a>"
-""",
- to: "dev@shiro.apache.org",
- recipientProviders: [[$class: 'DevelopersRecipientProvider']]
- )
- }
- }
- }
-
- // Send an email, if the last build was not successful and this one is.
- success {
- // Cleanup the build directory if the build was successful
- // (in this cae we probably don't have to do any post-build analysis)
- deleteDir()
- script {
- if ((env.BRANCH_NAME == "1.5.x" || env.BRANCH_NAME == "1.6.x" || env.BRANCH_NAME == "master") && (currentBuild.previousBuild != null) && (currentBuild.previousBuild.result != 'SUCCESS')) {
- emailext (
- subject: "[BUILD-STABLE]: Job '${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]'",
- body: """
-BUILD-STABLE: Job '${env.JOB_NAME} [${env.BRANCH_NAME}] [${env.BUILD_NUMBER}]':
-Is back to normal.
-""",
- to: "dev@shiro.apache.org",
- recipientProviders: [[$class: 'DevelopersRecipientProvider']]
- )
- }
- }
- }
- }
-
-}
\ No newline at end of file
diff --git a/NOTICE b/NOTICE
index 9d26a95..672ed80 100644
--- a/NOTICE
+++ b/NOTICE
@@ -9,7 +9,7 @@
available at http://www.javaspecialists.eu/archive/Issue015.html,
with continued modifications.
-Certain parts (StringUtils, IpAddressMatcher, etc.) of the source
-code for this product was copied for simplicity and to reduce
-dependencies from the source code developed by the Spring Framework
-Project (http://www.springframework.org).
+Certain parts (StringUtils, IpAddressMatcher, AntPathMatcherTests, etc.) of the
+source code for this product was copied for simplicity and to reduce
+dependencies from the source code developed by the Spring Framework Project
+(http://www.springframework.org).
diff --git a/RELEASE-NOTES b/RELEASE-NOTES
index 7b39af3..2bac2df 100644
--- a/RELEASE-NOTES
+++ b/RELEASE-NOTES
@@ -21,6 +21,58 @@
total set.
###########################################################
+# 1.7.1
+###########################################################
+
+Bug
+
+ [SHIRO-797] - Shiro 1.7.0 is lower than using springboot version 2.0.7 dependency error
+
+
+###########################################################
+# 1.7.0
+###########################################################
+
+Bug
+
+ [SHIRO-767] - org.apache.shiro.util.ClassUtil cannot load the array of Primitive DataType when use undertown as web container
+ [SHIRO-792] - ShiroWebFilterConfiguration seems to conflict with other FilterRegistrationBean
+
+New Feature
+
+ [SHIRO-789] - Also add cookie SameSite option to Spring
+
+Improvement
+
+ [SHIRO-740] - SslFilter with HTTP Strict Transport Security (HSTS)
+ [SHIRO-794] - Add system property to enable backslash path normalization
+ [SHIRO-795] - Disable session path rewriting by default
+
+Task
+
+ [SHIRO-793] - deleteMe cookie should use the defined "sameSite"
+
+
+###########################################################
+# 1.6.0
+###########################################################
+
+Bug
+
+ [SHIRO-610] - Incorrect filterchainResolver in 1.4.0-RC2
+ [SHIRO-762] - SecurityUtils.securityManager should be volatile
+ [SHIRO-766] - ArrayIndexOutOfBoundsException in Base64#decode
+
+New Feature
+
+ [SHIRO-788] - Add support for Global Filters
+
+Wish
+
+ [SHIRO-780] - NOTICE files of shiro components don't match NOTICE in source code repository
+
+
+###########################################################
# 1.5.3
###########################################################
diff --git a/config/core/src/main/java/org/apache/shiro/config/Ini.java b/config/core/src/main/java/org/apache/shiro/config/Ini.java
index 1f7c48d..a42d4a7 100644
--- a/config/core/src/main/java/org/apache/shiro/config/Ini.java
+++ b/config/core/src/main/java/org/apache/shiro/config/Ini.java
@@ -579,7 +579,7 @@
char c = line.charAt(i);
if (buildingKey) {
- if (isKeyValueSeparatorChar(c) && !isCharEscaped(line, i)) {
+ if (isKeyValueSeparatorChar(c) && !isCharEscaped(line, i) && !isCharEscaped(line, i-1)) {
buildingKey = false;//now start building the value
} else if (!isCharEscaped(line, i)){
keyBuffer.append(c);
diff --git a/config/core/src/test/groovy/org/apache/shiro/config/IniTest.groovy b/config/core/src/test/groovy/org/apache/shiro/config/IniTest.groovy
index cf9ee12..7df61c7 100644
--- a/config/core/src/test/groovy/org/apache/shiro/config/IniTest.groovy
+++ b/config/core/src/test/groovy/org/apache/shiro/config/IniTest.groovy
@@ -159,17 +159,11 @@
kv = Ini.Section.splitKeyValue(test);
assertEquals("Truth", kv[0]);
assertEquals("\\ Beauty\\", kv[1]);
- }
- /**
- * Tests if an escaped separator char will not be recognized as such.
- */
- @Test
- public void testSplitKeyValueEscapedEquals() {
- String test = "Truth\\=Beauty";
- String[] kv = Ini.Section.splitKeyValue(test);
- assertEquals("Truth", kv[0]);
- assertEquals("Beauty", kv[1]);
+ test = "cn\\=TheSpecial_GroupName,ou\\=groups,dc\\=example,dc\\=com = *:*"
+ kv = Ini.Section.splitKeyValue(test)
+ assertEquals("cn=TheSpecial_GroupName,ou=groups,dc=example,dc=com", kv[0])
+ assertEquals("*:*", kv[1])
}
@Test(expected = IllegalArgumentException.class)
diff --git a/core/src/main/java/org/apache/shiro/realm/ldap/DefaultLdapContextFactory.java b/core/src/main/java/org/apache/shiro/realm/ldap/DefaultLdapContextFactory.java
index db2b72c..8b8f4d5 100644
--- a/core/src/main/java/org/apache/shiro/realm/ldap/DefaultLdapContextFactory.java
+++ b/core/src/main/java/org/apache/shiro/realm/ldap/DefaultLdapContextFactory.java
@@ -205,25 +205,6 @@
return getLdapContext(systemUsername, systemPassword);
}
- /**
- * Deprecated - use {@link #getLdapContext(Object, Object)} instead. This will be removed before Apache Shiro 2.0.
- *
- * @param username the username to use when creating the connection.
- * @param password the password to use when creating the connection.
- * @return a {@code LdapContext} bound using the given username and password.
- * @throws javax.naming.NamingException if there is an error creating the context.
- * @deprecated the {@link #getLdapContext(Object, Object)} method should be used in all cases to ensure more than
- * String principals and credentials can be used. Shiro no longer calls this method - it will be
- * removed before the 2.0 release.
- */
- @Deprecated
- public LdapContext getLdapContext(String username, String password) throws NamingException {
- if (username != null && principalSuffix != null) {
- username += principalSuffix;
- }
- return getLdapContext((Object) username, password);
- }
-
public LdapContext getLdapContext(Object principal, Object credentials) throws NamingException {
if (url == null) {
throw new IllegalStateException("An LDAP URL must be specified of the form ldap://<hostname>:<port>");
@@ -314,4 +295,4 @@
}
}
-}
\ No newline at end of file
+}
diff --git a/core/src/main/java/org/apache/shiro/realm/ldap/JndiLdapContextFactory.java b/core/src/main/java/org/apache/shiro/realm/ldap/JndiLdapContextFactory.java
index 548057e..b1b22d8 100644
--- a/core/src/main/java/org/apache/shiro/realm/ldap/JndiLdapContextFactory.java
+++ b/core/src/main/java/org/apache/shiro/realm/ldap/JndiLdapContextFactory.java
@@ -399,23 +399,7 @@
* @throws NamingException if there is a problem connecting to the LDAP directory
*/
public LdapContext getSystemLdapContext() throws NamingException {
- return getLdapContext((Object)getSystemUsername(), getSystemPassword());
- }
-
- /**
- * Deprecated - use {@link #getLdapContext(Object, Object)} instead. This will be removed before Apache Shiro 2.0.
- *
- * @param username the username to use when creating the connection.
- * @param password the password to use when creating the connection.
- * @return a {@code LdapContext} bound using the given username and password.
- * @throws javax.naming.NamingException if there is an error creating the context.
- * @deprecated the {@link #getLdapContext(Object, Object)} method should be used in all cases to ensure more than
- * String principals and credentials can be used. Shiro no longer calls this method - it will be
- * removed before the 2.0 release.
- */
- @Deprecated
- public LdapContext getLdapContext(String username, String password) throws NamingException {
- return getLdapContext((Object) username, password);
+ return getLdapContext(getSystemUsername(), getSystemPassword());
}
/**
diff --git a/core/src/main/java/org/apache/shiro/realm/ldap/LdapContextFactory.java b/core/src/main/java/org/apache/shiro/realm/ldap/LdapContextFactory.java
index 0cc90fe..373bff7 100644
--- a/core/src/main/java/org/apache/shiro/realm/ldap/LdapContextFactory.java
+++ b/core/src/main/java/org/apache/shiro/realm/ldap/LdapContextFactory.java
@@ -40,20 +40,6 @@
LdapContext getSystemLdapContext() throws NamingException;
/**
- * Creates (or retrieves from a pool) a {@code LdapContext} connection bound using the username and password
- * specified.
- *
- * @param username the username to use when creating the connection.
- * @param password the password to use when creating the connection.
- * @return a {@code LdapContext} bound using the given username and password.
- * @throws javax.naming.NamingException if there is an error creating the context.
- * @deprecated the {@link #getLdapContext(Object, Object)} method should be used in all cases to ensure more than
- * String principals and credentials can be used.
- */
- @Deprecated
- LdapContext getLdapContext(String username, String password) throws NamingException;
-
- /**
* Creates (or retrieves from a pool) an {@code LdapContext} connection bound using the specified principal and
* credentials. The format of the principal and credentials are whatever is supported by the underlying
* LDAP {@link javax.naming.spi.InitialContextFactory InitialContextFactory} implementation. The default Sun
diff --git a/core/src/main/java/org/apache/shiro/realm/text/TextConfigurationRealm.java b/core/src/main/java/org/apache/shiro/realm/text/TextConfigurationRealm.java
index 0439f93..a33fbdd 100644
--- a/core/src/main/java/org/apache/shiro/realm/text/TextConfigurationRealm.java
+++ b/core/src/main/java/org/apache/shiro/realm/text/TextConfigurationRealm.java
@@ -211,9 +211,10 @@
protected static Set<String> toLines(String s) {
LinkedHashSet<String> set = new LinkedHashSet<String>();
- Scanner scanner = new Scanner(s);
- while (scanner.hasNextLine()) {
- set.add(scanner.nextLine());
+ try (Scanner scanner = new Scanner(s)) {
+ while (scanner.hasNextLine()) {
+ set.add(scanner.nextLine());
+ }
}
return set;
}
diff --git a/core/src/main/java/org/apache/shiro/util/AntPathMatcher.java b/core/src/main/java/org/apache/shiro/util/AntPathMatcher.java
index 4ba0695..29f1511 100644
--- a/core/src/main/java/org/apache/shiro/util/AntPathMatcher.java
+++ b/core/src/main/java/org/apache/shiro/util/AntPathMatcher.java
@@ -79,8 +79,15 @@
this.pathSeparator = (pathSeparator != null ? pathSeparator : DEFAULT_PATH_SEPARATOR);
}
-
+ /**
+ * Checks if {@code path} is a pattern (i.e. contains a '*', or '?'). For example the {@code /foo/**} would return {@code true}, while {@code /bar/} would return {@code false}.
+ * @param path the string to check
+ * @return this method returns {@code true} if {@code path} contains a '*' or '?', otherwise, {@code false}
+ */
public boolean isPattern(String path) {
+ if (path == null) {
+ return false;
+ }
return (path.indexOf('*') != -1 || path.indexOf('?') != -1);
}
@@ -108,12 +115,12 @@
* <code>false</code> if it didn't
*/
protected boolean doMatch(String pattern, String path, boolean fullMatch) {
- if (path.startsWith(this.pathSeparator) != pattern.startsWith(this.pathSeparator)) {
+ if (path == null || path.startsWith(this.pathSeparator) != pattern.startsWith(this.pathSeparator)) {
return false;
}
- String[] pattDirs = StringUtils.tokenizeToStringArray(pattern, this.pathSeparator);
- String[] pathDirs = StringUtils.tokenizeToStringArray(path, this.pathSeparator);
+ String[] pattDirs = StringUtils.tokenizeToStringArray(pattern, this.pathSeparator, false, true);
+ String[] pathDirs = StringUtils.tokenizeToStringArray(path, this.pathSeparator, false, true);
int pattIdxStart = 0;
int pattIdxEnd = pattDirs.length - 1;
@@ -395,33 +402,26 @@
* and '<code>path</code>', but does <strong>not</strong> enforce this.
*/
public String extractPathWithinPattern(String pattern, String path) {
- String[] patternParts = StringUtils.tokenizeToStringArray(pattern, this.pathSeparator);
- String[] pathParts = StringUtils.tokenizeToStringArray(path, this.pathSeparator);
+ String[] patternParts = StringUtils.tokenizeToStringArray(pattern, this.pathSeparator, false, true);
+ String[] pathParts = StringUtils.tokenizeToStringArray(path, this.pathSeparator, false, true);
+ StringBuilder builder = new StringBuilder();
+ boolean pathStarted = false;
- StringBuilder buffer = new StringBuilder();
-
- // Add any path parts that have a wildcarded pattern part.
- int puts = 0;
- for (int i = 0; i < patternParts.length; i++) {
- String patternPart = patternParts[i];
- if ((patternPart.indexOf('*') > -1 || patternPart.indexOf('?') > -1) && pathParts.length >= i + 1) {
- if (puts > 0 || (i == 0 && !pattern.startsWith(this.pathSeparator))) {
- buffer.append(this.pathSeparator);
+ for (int segment = 0; segment < patternParts.length; segment++) {
+ String patternPart = patternParts[segment];
+ if (patternPart.indexOf('*') > -1 || patternPart.indexOf('?') > -1) {
+ for (; segment < pathParts.length; segment++) {
+ if (pathStarted || (segment == 0 && !pattern.startsWith(this.pathSeparator))) {
+ builder.append(this.pathSeparator);
+ }
+ builder.append(pathParts[segment]);
+ pathStarted = true;
}
- buffer.append(pathParts[i]);
- puts++;
}
}
- // Append any trailing path parts.
- for (int i = patternParts.length; i < pathParts.length; i++) {
- if (puts > 0 || i > 0) {
- buffer.append(this.pathSeparator);
- }
- buffer.append(pathParts[i]);
- }
-
- return buffer.toString();
+ return builder.toString();
}
+
}
diff --git a/core/src/test/java/org/apache/shiro/authz/aop/PermissionAnnotationHandlerTest.java b/core/src/test/java/org/apache/shiro/authz/aop/PermissionAnnotationHandlerTest.java
index 84c70c6..a3c3e1f 100644
--- a/core/src/test/java/org/apache/shiro/authz/aop/PermissionAnnotationHandlerTest.java
+++ b/core/src/test/java/org/apache/shiro/authz/aop/PermissionAnnotationHandlerTest.java
@@ -22,10 +22,12 @@
import org.apache.shiro.authz.annotation.Logical;
import org.apache.shiro.authz.annotation.RequiresPermissions;
import org.apache.shiro.test.SecurityManagerTestSupport;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import java.lang.annotation.Annotation;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
/**
* Test cases for the {@link PermissionAnnotationHandler} class.
*/
@@ -33,48 +35,54 @@
//Added to satisfy SHIRO-146
- @Test(expected = UnauthenticatedException.class)
- public void testGuestSinglePermissionAssertion() throws Throwable {
+ @Test
+ public void testGuestSinglePermissionAssertion() {
PermissionAnnotationHandler handler = new PermissionAnnotationHandler();
Annotation requiresPermissionAnnotation = new RequiresPermissions() {
+ @Override
public String[] value() {
return new String[]{"test:test"};
}
+ @Override
public Class<? extends Annotation> annotationType() {
return RequiresPermissions.class;
}
- public Logical logical() {
+ @Override
+ public Logical logical() {
return Logical.AND;
}
};
- handler.assertAuthorized(requiresPermissionAnnotation);
+ assertThrows(UnauthenticatedException.class, () -> handler.assertAuthorized(requiresPermissionAnnotation));
}
//Added to satisfy SHIRO-146
- @Test(expected = UnauthenticatedException.class)
- public void testGuestMultiplePermissionAssertion() throws Throwable {
+ @Test
+ public void testGuestMultiplePermissionAssertion() {
PermissionAnnotationHandler handler = new PermissionAnnotationHandler();
Annotation requiresPermissionAnnotation = new RequiresPermissions() {
+ @Override
public String[] value() {
return new String[]{"test:test", "test2:test2"};
}
+ @Override
public Class<? extends Annotation> annotationType() {
return RequiresPermissions.class;
}
- public Logical logical() {
+ @Override
+ public Logical logical() {
return Logical.AND;
}
};
- handler.assertAuthorized(requiresPermissionAnnotation);
+ assertThrows(UnauthenticatedException.class, () -> handler.assertAuthorized(requiresPermissionAnnotation));
}
}
diff --git a/core/src/test/java/org/apache/shiro/authz/aop/RoleAnnotationHandlerTest.java b/core/src/test/java/org/apache/shiro/authz/aop/RoleAnnotationHandlerTest.java
index 4565598..bcde9f4 100644
--- a/core/src/test/java/org/apache/shiro/authz/aop/RoleAnnotationHandlerTest.java
+++ b/core/src/test/java/org/apache/shiro/authz/aop/RoleAnnotationHandlerTest.java
@@ -23,11 +23,14 @@
import org.apache.shiro.authz.annotation.RequiresRoles;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.test.SecurityManagerTestSupport;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
import java.lang.annotation.Annotation;
-import static org.easymock.EasyMock.*;
+import static org.easymock.EasyMock.createMock;
+import static org.easymock.EasyMock.expect;
+import static org.easymock.EasyMock.replay;
+import static org.junit.jupiter.api.Assertions.assertThrows;
/**
* Test cases for the {@link RoleAnnotationHandler} class.
@@ -37,72 +40,84 @@
//Added to satisfy SHIRO-146
- @Test(expected = UnauthenticatedException.class)
+ @Test
public void testGuestSingleRoleAssertion() throws Throwable {
RoleAnnotationHandler handler = new RoleAnnotationHandler();
Annotation requiresRolesAnnotation = new RequiresRoles() {
+ @Override
public String[] value() {
return new String[]{"blah"};
}
+ @Override
public Class<? extends Annotation> annotationType() {
return RequiresRoles.class;
}
- public Logical logical() {
- return Logical.AND;
- }
+
+ @Override
+ public Logical logical() {
+ return Logical.AND;
+ }
};
- handler.assertAuthorized(requiresRolesAnnotation);
+ assertThrows(UnauthenticatedException.class, () -> handler.assertAuthorized(requiresRolesAnnotation));
}
//Added to satisfy SHIRO-146
- @Test(expected = UnauthenticatedException.class)
+ @Test
public void testGuestMultipleRolesAssertion() throws Throwable {
RoleAnnotationHandler handler = new RoleAnnotationHandler();
Annotation requiresRolesAnnotation = new RequiresRoles() {
+ @Override
public String[] value() {
return new String[]{"blah", "blah2"};
}
+ @Override
public Class<? extends Annotation> annotationType() {
return RequiresRoles.class;
}
- public Logical logical() {
- return Logical.AND;
- }
+
+ @Override
+ public Logical logical() {
+ return Logical.AND;
+ }
};
- handler.assertAuthorized(requiresRolesAnnotation);
+ assertThrows(UnauthenticatedException.class, () -> handler.assertAuthorized(requiresRolesAnnotation));
}
-
+
@Test
- public void testOneOfTheRolesRequired() throws Throwable {
- subject = createMock(Subject.class);
- expect(subject.hasRole("blah")).andReturn(true);
- expect(subject.hasRole("blah2")).andReturn(false);
+ public void testOneOfTheRolesRequired() {
+ subject = createMock(Subject.class);
+ expect(subject.hasRole("blah")).andReturn(true);
+ expect(subject.hasRole("blah2")).andReturn(false);
replay(subject);
- RoleAnnotationHandler handler = new RoleAnnotationHandler() {
+ RoleAnnotationHandler handler = new RoleAnnotationHandler() {
@Override
- protected Subject getSubject() {
- return subject;
+ protected Subject getSubject() {
+ return subject;
}
};
Annotation requiresRolesAnnotation = new RequiresRoles() {
+ @Override
public String[] value() {
return new String[]{"blah", "blah2"};
}
+ @Override
public Class<? extends Annotation> annotationType() {
return RequiresRoles.class;
}
- public Logical logical() {
- return Logical.OR;
- }
+
+ @Override
+ public Logical logical() {
+ return Logical.OR;
+ }
};
handler.assertAuthorized(requiresRolesAnnotation);
}
diff --git a/core/src/test/java/org/apache/shiro/concurrent/SubjectAwareExecutorServiceTest.java b/core/src/test/java/org/apache/shiro/concurrent/SubjectAwareExecutorServiceTest.java
index 7d6a025..64e89a7 100644
--- a/core/src/test/java/org/apache/shiro/concurrent/SubjectAwareExecutorServiceTest.java
+++ b/core/src/test/java/org/apache/shiro/concurrent/SubjectAwareExecutorServiceTest.java
@@ -20,11 +20,18 @@
import org.apache.shiro.subject.support.SubjectRunnable;
import org.apache.shiro.test.SecurityManagerTestSupport;
-import org.junit.Test;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
-import java.util.concurrent.*;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
-import static org.easymock.EasyMock.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
/**
* Test cases for the {@link SubjectAwareExecutorService} implementation.
@@ -34,40 +41,42 @@
@SuppressWarnings({"unchecked"})
@Test
public void testSubmitRunnable() {
- ExecutorService mockExecutorService = createNiceMock(ExecutorService.class);
- expect(mockExecutorService.submit(isA(SubjectRunnable.class))).andReturn(new DummyFuture());
- replay(mockExecutorService);
+ ExecutorService mockExecutorService = mock(ExecutorService.class);
+ ArgumentCaptor<SubjectRunnable> captor = ArgumentCaptor.forClass(SubjectRunnable.class);
+ when(mockExecutorService.submit(captor.capture())).thenReturn(new DummyFuture<>());
final SubjectAwareExecutorService executor = new SubjectAwareExecutorService(mockExecutorService);
- Runnable testRunnable = new Runnable() {
- public void run() {
- System.out.println("Hello World");
- }
- };
+ Runnable testRunnable = () -> System.out.println("Hello World");
executor.submit(testRunnable);
- verify(mockExecutorService);
+ SubjectRunnable subjectRunnable = captor.getValue();
+ Assertions.assertNotNull(subjectRunnable);
}
- private class DummyFuture<V> implements Future<V> {
+ private static class DummyFuture<V> implements Future<V> {
+ @Override
public boolean cancel(boolean b) {
return false;
}
+ @Override
public boolean isCancelled() {
return false;
}
+ @Override
public boolean isDone() {
return true;
}
+ @Override
public V get() throws InterruptedException, ExecutionException {
return null;
}
+ @Override
public V get(long l, TimeUnit timeUnit) throws InterruptedException, ExecutionException, TimeoutException {
return null;
}
diff --git a/core/src/test/java/org/apache/shiro/concurrent/SubjectAwareExecutorTest.java b/core/src/test/java/org/apache/shiro/concurrent/SubjectAwareExecutorTest.java
index 29d0148..bf50625 100644
--- a/core/src/test/java/org/apache/shiro/concurrent/SubjectAwareExecutorTest.java
+++ b/core/src/test/java/org/apache/shiro/concurrent/SubjectAwareExecutorTest.java
@@ -20,11 +20,14 @@
import org.apache.shiro.subject.support.SubjectRunnable;
import org.apache.shiro.test.SecurityManagerTestSupport;
-import org.junit.Test;
+import org.junit.jupiter.api.Test;
+import org.mockito.ArgumentCaptor;
import java.util.concurrent.Executor;
-import static org.easymock.EasyMock.*;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
/**
* Test cases for the {@link SubjectAwareExecutor} implementation.
@@ -35,21 +38,17 @@
@Test
public void testExecute() {
- Executor targetMockExecutor = createNiceMock(Executor.class);
- //* ensure the target Executor receives a SubjectRunnable instance that retains the subject identity:
- //(this is what verifies the test is valid):
- targetMockExecutor.execute(isA(SubjectRunnable.class));
- replay(targetMockExecutor);
-
+ Executor targetMockExecutor = mock(Executor.class);
final SubjectAwareExecutor executor = new SubjectAwareExecutor(targetMockExecutor);
- Runnable work = new Runnable() {
- public void run() {
- System.out.println("Hello World");
- }
- };
+ Runnable work = () -> System.out.println("Hello World");
executor.execute(work);
- verify(targetMockExecutor);
+ //* ensure the target Executor receives a SubjectRunnable instance that retains the subject identity:
+ //(this is what verifies the test is valid):
+ ArgumentCaptor<SubjectRunnable> subjectRunnableArgumentCaptor = ArgumentCaptor.forClass(SubjectRunnable.class);
+ verify(targetMockExecutor).execute(subjectRunnableArgumentCaptor.capture());
+ SubjectRunnable subjectRunnable = subjectRunnableArgumentCaptor.getValue();
+ assertNotNull(subjectRunnable);
}
}
diff --git a/core/src/test/java/org/apache/shiro/realm/ldap/DefaultLdapContextFactoryTest.java b/core/src/test/java/org/apache/shiro/realm/ldap/DefaultLdapContextFactoryTest.java
index 9a52a3b..b383fb7 100644
--- a/core/src/test/java/org/apache/shiro/realm/ldap/DefaultLdapContextFactoryTest.java
+++ b/core/src/test/java/org/apache/shiro/realm/ldap/DefaultLdapContextFactoryTest.java
@@ -61,12 +61,12 @@
//garbage URL to test that the context is being created, but fails:
String brokenHost = UUID.randomUUID().toString();
factory.setUrl("ldap://" + brokenHost + ":389");
- factory.getLdapContext((Object) "foo", "bar");
+ factory.getLdapContext("foo", "bar");
}
@Test(expected = IllegalStateException.class)
public void testGetLdapContextWithoutUrl() throws NamingException {
- factory.getLdapContext((Object) "foo", "bar");
+ factory.getLdapContext("foo", "bar");
}
@@ -76,25 +76,25 @@
@Test(expected = AuthenticationException.class)
public void testEmptyStringCredentials() throws NamingException {
factory.setUrl("ldap://localhost:389");
- factory.getLdapContext((Object)"jcoder", "");
+ factory.getLdapContext("jcoder", "");
}
@Test(expected = AuthenticationException.class)
public void testEmptyCharArrayCredentials() throws NamingException {
factory.setUrl("ldap://localhost:389");
- factory.getLdapContext((Object)"jcoder", new char[0]);
+ factory.getLdapContext("jcoder", new char[0]);
}
@Test(expected = AuthenticationException.class)
public void testEmptyByteArrayCredentials() throws NamingException {
factory.setUrl("ldap://localhost:389");
- factory.getLdapContext((Object)"jcoder", new byte[0]);
+ factory.getLdapContext("jcoder", new byte[0]);
}
@Test(expected = AuthenticationException.class)
public void testEmptyNullCredentials() throws NamingException {
factory.setUrl("ldap://localhost:389");
- factory.getLdapContext((Object)"jcoder", null);
+ factory.getLdapContext("jcoder", null);
}
diff --git a/core/src/test/java/org/apache/shiro/realm/ldap/JndiLdapContextFactoryTest.java b/core/src/test/java/org/apache/shiro/realm/ldap/JndiLdapContextFactoryTest.java
index 87ce184..a1e0ee7 100644
--- a/core/src/test/java/org/apache/shiro/realm/ldap/JndiLdapContextFactoryTest.java
+++ b/core/src/test/java/org/apache/shiro/realm/ldap/JndiLdapContextFactoryTest.java
@@ -66,7 +66,7 @@
//garbage URL to test that the context is being created, but fails:
String brokenHost = UUID.randomUUID().toString();
factory.setUrl("ldap://" + brokenHost + ":389");
- factory.getLdapContext((Object) "foo", "bar");
+ factory.getLdapContext("foo", "bar");
}
@Test
@@ -105,7 +105,7 @@
@Test(expected = IllegalStateException.class)
public void testGetLdapContextWithoutUrl() throws NamingException {
- factory.getLdapContext((Object) "foo", "bar");
+ factory.getLdapContext("foo", "bar");
}
@Test
@@ -123,7 +123,7 @@
};
factory.setUrl("ldap://localhost:389");
- factory.getLdapContext((Object) "foo", "bar");
+ factory.getLdapContext("foo", "bar");
}
@SuppressWarnings({"deprecation"})
@@ -189,25 +189,25 @@
@Test(expected = AuthenticationException.class)
public void testEmptyStringCredentials() throws NamingException {
factory.setUrl("ldap://localhost:389");
- factory.getLdapContext((Object)"jcoder", "");
+ factory.getLdapContext("jcoder", "");
}
@Test(expected = AuthenticationException.class)
public void testEmptyCharArrayCredentials() throws NamingException {
factory.setUrl("ldap://localhost:389");
- factory.getLdapContext((Object)"jcoder", new char[0]);
+ factory.getLdapContext("jcoder", new char[0]);
}
@Test(expected = AuthenticationException.class)
public void testEmptyByteArrayCredentials() throws NamingException {
factory.setUrl("ldap://localhost:389");
- factory.getLdapContext((Object)"jcoder", new byte[0]);
+ factory.getLdapContext("jcoder", new byte[0]);
}
@Test(expected = AuthenticationException.class)
public void testEmptyNullCredentials() throws NamingException {
factory.setUrl("ldap://localhost:389");
- factory.getLdapContext((Object)"jcoder", null);
+ factory.getLdapContext("jcoder", null);
}
diff --git a/core/src/test/java/org/apache/shiro/test/SecurityManagerTestSupport.java b/core/src/test/java/org/apache/shiro/test/SecurityManagerTestSupport.java
index 8b3f3a6..486406f 100644
--- a/core/src/test/java/org/apache/shiro/test/SecurityManagerTestSupport.java
+++ b/core/src/test/java/org/apache/shiro/test/SecurityManagerTestSupport.java
@@ -20,14 +20,14 @@
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.config.Ini;
+import org.apache.shiro.lang.util.LifecycleUtils;
import org.apache.shiro.mgt.DefaultSecurityManager;
import org.apache.shiro.mgt.SecurityManager;
import org.apache.shiro.realm.text.IniRealm;
import org.apache.shiro.subject.Subject;
-import org.apache.shiro.lang.util.LifecycleUtils;
import org.apache.shiro.util.ThreadContext;
-import org.junit.After;
-import org.junit.Before;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
/**
* Utility methods for use by Shiro test case subclasses. You can use these methods as examples for your own
@@ -64,12 +64,12 @@
return SecurityUtils.getSubject();
}
- @Before
+ @BeforeEach
public void setup() {
createAndBindTestSubject();
}
- @After
+ @AfterEach
public void teardown() {
ThreadContext.remove();
}
diff --git a/core/src/test/java/org/apache/shiro/util/AntPathMatcherTests.java b/core/src/test/java/org/apache/shiro/util/AntPathMatcherTests.java
new file mode 100644
index 0000000..383686a
--- /dev/null
+++ b/core/src/test/java/org/apache/shiro/util/AntPathMatcherTests.java
@@ -0,0 +1,330 @@
+/*
+ * 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.shiro.util;
+
+import org.junit.Test;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.assertFalse;
+
+/**
+ * Unit tests for {@link AntPathMatcher}.
+ *
+ * Adapted from <a href="https://github.com/spring-projects/spring-framework/blob/b92d249f450920e48e640af6bbd0bd509e7d707d/spring-core/src/test/java/org/springframework/util/AntPathMatcherTests.java"/>Spring Framework's similar AntPathMatcherTests</a>
+ */
+public class AntPathMatcherTests {
+
+ private final AntPathMatcher pathMatcher = new AntPathMatcher();
+
+ @Test
+ public void match() {
+ // test exact matching
+ assertTrue(pathMatcher.match("test", "test"));
+ assertTrue(pathMatcher.match("/test", "/test"));
+ assertTrue(pathMatcher.match("https://example.org", "https://example.org"));
+ assertFalse(pathMatcher.match("/test.jpg", "test.jpg"));
+ assertFalse(pathMatcher.match("test", "/test"));
+ assertFalse(pathMatcher.match("/test", "test"));
+
+ // test matching with ?'s
+ assertTrue(pathMatcher.match("t?st", "test"));
+ assertTrue(pathMatcher.match("??st", "test"));
+ assertTrue(pathMatcher.match("tes?", "test"));
+ assertTrue(pathMatcher.match("te??", "test"));
+ assertTrue(pathMatcher.match("?es?", "test"));
+ assertFalse(pathMatcher.match("tes?", "tes"));
+ assertFalse(pathMatcher.match("tes?", "testt"));
+ assertFalse(pathMatcher.match("tes?", "tsst"));
+
+ // test matching with *'s
+ assertTrue(pathMatcher.match("*", "test"));
+ assertTrue(pathMatcher.match("test*", "test"));
+ assertTrue(pathMatcher.match("test*", "testTest"));
+ assertTrue(pathMatcher.match("test/*", "test/Test"));
+ assertTrue(pathMatcher.match("test/*", "test/t"));
+ assertTrue(pathMatcher.match("test/*", "test/"));
+ assertTrue(pathMatcher.match("*test*", "AnothertestTest"));
+ assertTrue(pathMatcher.match("*test", "Anothertest"));
+ assertTrue(pathMatcher.match("*.*", "test."));
+ assertTrue(pathMatcher.match("*.*", "test.test"));
+ assertTrue(pathMatcher.match("*.*", "test.test.test"));
+ assertTrue(pathMatcher.match("test*aaa", "testblaaaa"));
+ assertFalse(pathMatcher.match("test*", "tst"));
+ assertFalse(pathMatcher.match("test*", "tsttest"));
+ assertFalse(pathMatcher.match("test*", "test/"));
+ assertFalse(pathMatcher.match("test*", "test/t"));
+ assertFalse(pathMatcher.match("test/*", "test"));
+ assertFalse(pathMatcher.match("*test*", "tsttst"));
+ assertFalse(pathMatcher.match("*test", "tsttst"));
+ assertFalse(pathMatcher.match("*.*", "tsttst"));
+ assertFalse(pathMatcher.match("test*aaa", "test"));
+ assertFalse(pathMatcher.match("test*aaa", "testblaaab"));
+
+ // test matching with ?'s and /'s
+ assertTrue(pathMatcher.match("/?", "/a"));
+ assertTrue(pathMatcher.match("/?/a", "/a/a"));
+ assertTrue(pathMatcher.match("/a/?", "/a/b"));
+ assertTrue(pathMatcher.match("/??/a", "/aa/a"));
+ assertTrue(pathMatcher.match("/a/??", "/a/bb"));
+ assertTrue(pathMatcher.match("/?", "/a"));
+
+ // test matching with **'s
+ assertTrue(pathMatcher.match("/**", "/testing/testing"));
+ assertTrue(pathMatcher.match("/*/**", "/testing/testing"));
+ assertTrue(pathMatcher.match("/**/*", "/testing/testing"));
+ assertTrue(pathMatcher.match("/bla/**/bla", "/bla/testing/testing/bla"));
+ assertTrue(pathMatcher.match("/bla/**/bla", "/bla/testing/testing/bla/bla"));
+ assertTrue(pathMatcher.match("/**/test", "/bla/bla/test"));
+ assertTrue(pathMatcher.match("/bla/**/**/bla", "/bla/bla/bla/bla/bla/bla"));
+ assertTrue(pathMatcher.match("/bla*bla/test", "/blaXXXbla/test"));
+ assertTrue(pathMatcher.match("/*bla/test", "/XXXbla/test"));
+ assertFalse(pathMatcher.match("/bla*bla/test", "/blaXXXbl/test"));
+ assertFalse(pathMatcher.match("/*bla/test", "XXXblab/test"));
+ assertFalse(pathMatcher.match("/*bla/test", "XXXbl/test"));
+
+ assertFalse(pathMatcher.match("/????", "/bala/bla"));
+ assertFalse(pathMatcher.match("/**/*bla", "/bla/bla/bla/bbb"));
+
+ assertTrue(pathMatcher.match("/*bla*/**/bla/**", "/XXXblaXXXX/testing/testing/bla/testing/testing/"));
+ assertTrue(pathMatcher.match("/*bla*/**/bla/*", "/XXXblaXXXX/testing/testing/bla/testing"));
+ assertTrue(pathMatcher.match("/*bla*/**/bla/**", "/XXXblaXXXX/testing/testing/bla/testing/testing"));
+ assertTrue(pathMatcher.match("/*bla*/**/bla/**", "/XXXblaXXXX/testing/testing/bla/testing/testing.jpg"));
+
+ assertTrue(pathMatcher.match("*bla*/**/bla/**", "XXXblaXXXX/testing/testing/bla/testing/testing/"));
+ assertTrue(pathMatcher.match("*bla*/**/bla/*", "XXXblaXXXX/testing/testing/bla/testing"));
+ assertTrue(pathMatcher.match("*bla*/**/bla/**", "XXXblaXXXX/testing/testing/bla/testing/testing"));
+ assertFalse(pathMatcher.match("*bla*/**/bla/*", "XXXblaXXXX/testing/testing/bla/testing/testing"));
+
+ assertFalse(pathMatcher.match("/x/x/**/bla", "/x/x/x/"));
+
+ assertTrue(pathMatcher.match("/foo/bar/**", "/foo/bar"));
+
+ assertTrue(pathMatcher.match("", ""));
+ }
+
+ @Test
+ public void matchWithNullPath() {
+ assertFalse(pathMatcher.match("/test", null));
+ assertFalse(pathMatcher.match("/", null));
+ assertFalse(pathMatcher.match(null, null));
+ }
+
+ @Test
+ public void matchStart() {
+ // test exact matching
+ assertTrue(pathMatcher.matchStart("test", "test"));
+ assertTrue(pathMatcher.matchStart("/test", "/test"));
+ assertFalse(pathMatcher.matchStart("/test.jpg", "test.jpg"));
+ assertFalse(pathMatcher.matchStart("test", "/test"));
+ assertFalse(pathMatcher.matchStart("/test", "test"));
+
+ // test matching with ?'s
+ assertTrue(pathMatcher.matchStart("t?st", "test"));
+ assertTrue(pathMatcher.matchStart("??st", "test"));
+ assertTrue(pathMatcher.matchStart("tes?", "test"));
+ assertTrue(pathMatcher.matchStart("te??", "test"));
+ assertTrue(pathMatcher.matchStart("?es?", "test"));
+ assertFalse(pathMatcher.matchStart("tes?", "tes"));
+ assertFalse(pathMatcher.matchStart("tes?", "testt"));
+ assertFalse(pathMatcher.matchStart("tes?", "tsst"));
+
+ // test matching with *'s
+ assertTrue(pathMatcher.matchStart("*", "test"));
+ assertTrue(pathMatcher.matchStart("test*", "test"));
+ assertTrue(pathMatcher.matchStart("test*", "testTest"));
+ assertTrue(pathMatcher.matchStart("test/*", "test/Test"));
+ assertTrue(pathMatcher.matchStart("test/*", "test/t"));
+ assertTrue(pathMatcher.matchStart("test/*", "test/"));
+ assertTrue(pathMatcher.matchStart("*test*", "AnothertestTest"));
+ assertTrue(pathMatcher.matchStart("*test", "Anothertest"));
+ assertTrue(pathMatcher.matchStart("*.*", "test."));
+ assertTrue(pathMatcher.matchStart("*.*", "test.test"));
+ assertTrue(pathMatcher.matchStart("*.*", "test.test.test"));
+ assertTrue(pathMatcher.matchStart("test*aaa", "testblaaaa"));
+ assertFalse(pathMatcher.matchStart("test*", "tst"));
+ assertFalse(pathMatcher.matchStart("test*", "test/"));
+ assertFalse(pathMatcher.matchStart("test*", "tsttest"));
+ assertFalse(pathMatcher.matchStart("test*", "test/"));
+ assertFalse(pathMatcher.matchStart("test*", "test/t"));
+ assertTrue(pathMatcher.matchStart("test/*", "test"));
+ assertTrue(pathMatcher.matchStart("test/t*.txt", "test"));
+ assertFalse(pathMatcher.matchStart("*test*", "tsttst"));
+ assertFalse(pathMatcher.matchStart("*test", "tsttst"));
+ assertFalse(pathMatcher.matchStart("*.*", "tsttst"));
+ assertFalse(pathMatcher.matchStart("test*aaa", "test"));
+ assertFalse(pathMatcher.matchStart("test*aaa", "testblaaab"));
+
+ // test matching with ?'s and /'s
+ assertTrue(pathMatcher.matchStart("/?", "/a"));
+ assertTrue(pathMatcher.matchStart("/?/a", "/a/a"));
+ assertTrue(pathMatcher.matchStart("/a/?", "/a/b"));
+ assertTrue(pathMatcher.matchStart("/??/a", "/aa/a"));
+ assertTrue(pathMatcher.matchStart("/a/??", "/a/bb"));
+ assertTrue(pathMatcher.matchStart("/?", "/a"));
+
+ // test matching with **'s
+ assertTrue(pathMatcher.matchStart("/**", "/testing/testing"));
+ assertTrue(pathMatcher.matchStart("/*/**", "/testing/testing"));
+ assertTrue(pathMatcher.matchStart("/**/*", "/testing/testing"));
+ assertTrue(pathMatcher.matchStart("test*/**", "test/"));
+ assertTrue(pathMatcher.matchStart("test*/**", "test/t"));
+ assertTrue(pathMatcher.matchStart("/bla/**/bla", "/bla/testing/testing/bla"));
+ assertTrue(pathMatcher.matchStart("/bla/**/bla", "/bla/testing/testing/bla/bla"));
+ assertTrue(pathMatcher.matchStart("/**/test", "/bla/bla/test"));
+ assertTrue(pathMatcher.matchStart("/bla/**/**/bla", "/bla/bla/bla/bla/bla/bla"));
+ assertTrue(pathMatcher.matchStart("/bla*bla/test", "/blaXXXbla/test"));
+ assertTrue(pathMatcher.matchStart("/*bla/test", "/XXXbla/test"));
+ assertFalse(pathMatcher.matchStart("/bla*bla/test", "/blaXXXbl/test"));
+ assertFalse(pathMatcher.matchStart("/*bla/test", "XXXblab/test"));
+ assertFalse(pathMatcher.matchStart("/*bla/test", "XXXbl/test"));
+
+ assertFalse(pathMatcher.matchStart("/????", "/bala/bla"));
+ assertTrue(pathMatcher.matchStart("/**/*bla", "/bla/bla/bla/bbb"));
+
+ assertTrue(pathMatcher.matchStart("/*bla*/**/bla/**", "/XXXblaXXXX/testing/testing/bla/testing/testing/"));
+ assertTrue(pathMatcher.matchStart("/*bla*/**/bla/*", "/XXXblaXXXX/testing/testing/bla/testing"));
+ assertTrue(pathMatcher.matchStart("/*bla*/**/bla/**", "/XXXblaXXXX/testing/testing/bla/testing/testing"));
+ assertTrue(pathMatcher.matchStart("/*bla*/**/bla/**", "/XXXblaXXXX/testing/testing/bla/testing/testing.jpg"));
+
+ assertTrue(pathMatcher.matchStart("*bla*/**/bla/**", "XXXblaXXXX/testing/testing/bla/testing/testing/"));
+ assertTrue(pathMatcher.matchStart("*bla*/**/bla/*", "XXXblaXXXX/testing/testing/bla/testing"));
+ assertTrue(pathMatcher.matchStart("*bla*/**/bla/**", "XXXblaXXXX/testing/testing/bla/testing/testing"));
+ assertTrue(pathMatcher.matchStart("*bla*/**/bla/*", "XXXblaXXXX/testing/testing/bla/testing/testing"));
+
+ assertTrue(pathMatcher.matchStart("/x/x/**/bla", "/x/x/x/"));
+
+ assertTrue(pathMatcher.matchStart("", ""));
+ }
+
+ @Test
+ public void uniqueDeliminator() {
+ pathMatcher.setPathSeparator(".");
+
+ // test exact matching
+ assertTrue(pathMatcher.match("test", "test"));
+ assertTrue(pathMatcher.match(".test", ".test"));
+ assertFalse(pathMatcher.match(".test/jpg", "test/jpg"));
+ assertFalse(pathMatcher.match("test", ".test"));
+ assertFalse(pathMatcher.match(".test", "test"));
+
+ // test matching with ?'s
+ assertTrue(pathMatcher.match("t?st", "test"));
+ assertTrue(pathMatcher.match("??st", "test"));
+ assertTrue(pathMatcher.match("tes?", "test"));
+ assertTrue(pathMatcher.match("te??", "test"));
+ assertTrue(pathMatcher.match("?es?", "test"));
+ assertFalse(pathMatcher.match("tes?", "tes"));
+ assertFalse(pathMatcher.match("tes?", "testt"));
+ assertFalse(pathMatcher.match("tes?", "tsst"));
+
+ // test matching with *'s
+ assertTrue(pathMatcher.match("*", "test"));
+ assertTrue(pathMatcher.match("test*", "test"));
+ assertTrue(pathMatcher.match("test*", "testTest"));
+ assertTrue(pathMatcher.match("*test*", "AnothertestTest"));
+ assertTrue(pathMatcher.match("*test", "Anothertest"));
+ assertTrue(pathMatcher.match("*/*", "test/"));
+ assertTrue(pathMatcher.match("*/*", "test/test"));
+ assertTrue(pathMatcher.match("*/*", "test/test/test"));
+ assertTrue(pathMatcher.match("test*aaa", "testblaaaa"));
+ assertFalse(pathMatcher.match("test*", "tst"));
+ assertFalse(pathMatcher.match("test*", "tsttest"));
+ assertFalse(pathMatcher.match("*test*", "tsttst"));
+ assertFalse(pathMatcher.match("*test", "tsttst"));
+ assertFalse(pathMatcher.match("*/*", "tsttst"));
+ assertFalse(pathMatcher.match("test*aaa", "test"));
+ assertFalse(pathMatcher.match("test*aaa", "testblaaab"));
+
+ // test matching with ?'s and .'s
+ assertTrue(pathMatcher.match(".?", ".a"));
+ assertTrue(pathMatcher.match(".?.a", ".a.a"));
+ assertTrue(pathMatcher.match(".a.?", ".a.b"));
+ assertTrue(pathMatcher.match(".??.a", ".aa.a"));
+ assertTrue(pathMatcher.match(".a.??", ".a.bb"));
+ assertTrue(pathMatcher.match(".?", ".a"));
+
+ // test matching with **'s
+ assertTrue(pathMatcher.match(".**", ".testing.testing"));
+ assertTrue(pathMatcher.match(".*.**", ".testing.testing"));
+ assertTrue(pathMatcher.match(".**.*", ".testing.testing"));
+ assertTrue(pathMatcher.match(".bla.**.bla", ".bla.testing.testing.bla"));
+ assertTrue(pathMatcher.match(".bla.**.bla", ".bla.testing.testing.bla.bla"));
+ assertTrue(pathMatcher.match(".**.test", ".bla.bla.test"));
+ assertTrue(pathMatcher.match(".bla.**.**.bla", ".bla.bla.bla.bla.bla.bla"));
+ assertTrue(pathMatcher.match(".bla*bla.test", ".blaXXXbla.test"));
+ assertTrue(pathMatcher.match(".*bla.test", ".XXXbla.test"));
+ assertFalse(pathMatcher.match(".bla*bla.test", ".blaXXXbl.test"));
+ assertFalse(pathMatcher.match(".*bla.test", "XXXblab.test"));
+ assertFalse(pathMatcher.match(".*bla.test", "XXXbl.test"));
+ }
+
+ @Test
+ public void extractPathWithinPattern() throws Exception {
+ assertEquals(pathMatcher.extractPathWithinPattern("/docs/commit.html", "/docs/commit.html"), "");
+
+ assertEquals(pathMatcher.extractPathWithinPattern("/docs/*", "/docs/cvs/commit"), "cvs/commit");
+ assertEquals(pathMatcher.extractPathWithinPattern("/docs/cvs/*.html", "/docs/cvs/commit.html"), "commit.html");
+ assertEquals(pathMatcher.extractPathWithinPattern("/docs/**", "/docs/cvs/commit"), "cvs/commit");
+ assertEquals(pathMatcher.extractPathWithinPattern("/docs/**/*.html", "/docs/cvs/commit.html"), "cvs/commit.html");
+ assertEquals(pathMatcher.extractPathWithinPattern("/docs/**/*.html", "/docs/commit.html"), "commit.html");
+ assertEquals(pathMatcher.extractPathWithinPattern("/*.html", "/commit.html"), "commit.html");
+ assertEquals(pathMatcher.extractPathWithinPattern("/*.html", "/docs/commit.html"), "docs/commit.html");
+ assertEquals(pathMatcher.extractPathWithinPattern("*.html", "/commit.html"), "/commit.html");
+ assertEquals(pathMatcher.extractPathWithinPattern("*.html", "/docs/commit.html"), "/docs/commit.html");
+ assertEquals(pathMatcher.extractPathWithinPattern("**/*.*", "/docs/commit.html"), "/docs/commit.html");
+ assertEquals(pathMatcher.extractPathWithinPattern("*", "/docs/commit.html"), "/docs/commit.html");
+ assertEquals(pathMatcher.extractPathWithinPattern("**/commit.html", "/docs/cvs/other/commit.html"), "/docs/cvs/other/commit.html");
+ assertEquals(pathMatcher.extractPathWithinPattern("/docs/**/commit.html", "/docs/cvs/other/commit.html"), "cvs/other/commit.html");
+ assertEquals(pathMatcher.extractPathWithinPattern("/docs/**/**/**/**", "/docs/cvs/other/commit.html"), "cvs/other/commit.html");
+
+ assertEquals(pathMatcher.extractPathWithinPattern("/d?cs/*", "/docs/cvs/commit"), "docs/cvs/commit");
+ assertEquals(pathMatcher.extractPathWithinPattern("/docs/c?s/*.html", "/docs/cvs/commit.html"), "cvs/commit.html");
+ assertEquals(pathMatcher.extractPathWithinPattern("/d?cs/**", "/docs/cvs/commit"), "docs/cvs/commit");
+ assertEquals(pathMatcher.extractPathWithinPattern("/d?cs/**/*.html", "/docs/cvs/commit.html"), "docs/cvs/commit.html");
+ }
+
+ @Test
+ public void spaceInTokens() {
+ assertTrue(pathMatcher.match("/group/sales/members", "/group/sales/members"));
+ assertFalse(pathMatcher.match("/group/sales/members", "/Group/ sales/Members"));
+ }
+
+ @Test
+ public void isPattern() {
+ assertTrue(pathMatcher.isPattern("/test/*"));
+ assertTrue(pathMatcher.isPattern("/test/**/name"));
+ assertTrue(pathMatcher.isPattern("/test?"));
+
+ assertFalse(pathMatcher.isPattern("/test/{name}"));
+ assertFalse(pathMatcher.isPattern("/test/name"));
+ assertFalse(pathMatcher.isPattern("/test/foo{bar"));
+ }
+
+ @Test
+ public void matches() {
+ assertTrue(pathMatcher.matches("/foo/*", "/foo/"));
+ }
+
+ @Test
+ public void isPatternWithNullPath() {
+ assertFalse(pathMatcher.isPattern(null));
+ }
+}
\ No newline at end of file
diff --git a/crypto/cipher/src/main/java/org/apache/shiro/crypto/cipher/AesCipherService.java b/crypto/cipher/src/main/java/org/apache/shiro/crypto/cipher/AesCipherService.java
index f8c63b1..3b1a058 100644
--- a/crypto/cipher/src/main/java/org/apache/shiro/crypto/cipher/AesCipherService.java
+++ b/crypto/cipher/src/main/java/org/apache/shiro/crypto/cipher/AesCipherService.java
@@ -89,6 +89,9 @@
* <b>**</b>Since {@code GCM} is a stream cipher, padding is implemented in the operation mode and an external padding scheme
* cannot be used in conjunction with {@code GCM}. In fact, {@code AES/GCM/PKCS5Padding} is just an alias in most JVM for
* {@code AES/GCM/NoPadding}.
+ * <p/>
+ * <b>NOTE:</b> As of Java 14, setting a streaming padding for the above example will throw a NoSuchAlgorithmException
+ * @see <a href="https://www.oracle.com/java/technologies/javase/14-relnote-issues.html#JDK-8180392">JDK-8180392</a>
*/
public AesCipherService() {
super(ALGORITHM_NAME);
diff --git a/integration-tests/guice3/pom.xml b/integration-tests/guice3/pom.xml
index 37326b4..e335cbb 100644
--- a/integration-tests/guice3/pom.xml
+++ b/integration-tests/guice3/pom.xml
@@ -123,4 +123,17 @@
</dependency>
</dependencies>
+ <profiles>
+ <profile>
+ <id>jdk16</id>
+ <activation>
+ <jdk>[16,)</jdk>
+ </activation>
+ <properties>
+ <!-- needed by guice until it is compatible with jdk16+. -->
+ <surefire.argLine>--illegal-access=permit</surefire.argLine>
+ <failsafe.argLine>--illegal-access=permit</failsafe.argLine>
+ </properties>
+ </profile>
+ </profiles>
</project>
diff --git a/integration-tests/guice4/pom.xml b/integration-tests/guice4/pom.xml
index 37f45ca..0e5af10 100644
--- a/integration-tests/guice4/pom.xml
+++ b/integration-tests/guice4/pom.xml
@@ -128,4 +128,17 @@
</dependency>
</dependencies>
+ <profiles>
+ <profile>
+ <id>jdk16</id>
+ <activation>
+ <jdk>[16,)</jdk>
+ </activation>
+ <properties>
+ <!-- needed by guice until it is compatible with jdk16+. -->
+ <surefire.argLine>--illegal-access=permit</surefire.argLine>
+ <failsafe.argLine>--illegal-access=permit</failsafe.argLine>
+ </properties>
+ </profile>
+ </profiles>
</project>
diff --git a/pom.xml b/pom.xml
index 3c0ea81..91be17f 100644
--- a/pom.xml
+++ b/pom.xml
@@ -44,7 +44,7 @@
<connection>scm:git:https://gitbox.apache.org/repos/asf/shiro.git</connection>
<developerConnection>scm:git:https://gitbox.apache.org/repos/asf/shiro.git</developerConnection>
<url>https://github.com/apache/shiro/tree/${project.scm.tag}</url>
- <tag>master</tag>
+ <tag>main</tag>
</scm>
<issueManagement>
<system>Jira</system>
@@ -66,10 +66,14 @@
<properties>
- <shiro.previousVersion>1.6.0</shiro.previousVersion>
+ <shiro.previousVersion>1.7.1</shiro.previousVersion>
<!-- Replaced by the build number plugin at build time: -->
<buildNumber>${user.name}-${maven.build.timestamp}</buildNumber>
<jacoco.skip>true</jacoco.skip>
+ <!--suppress CheckTagEmptyBody -->
+ <surefire.argLine></surefire.argLine>
+ <!--suppress CheckTagEmptyBody -->
+ <failsafe.argLine></failsafe.argLine>
<!-- non-dependency-based properties: -->
<shiro.osgi.importRange>[2, 3)</shiro.osgi.importRange>
@@ -110,8 +114,9 @@
<!-- Test 3rd-party dependencies: -->
<easymock.version>4.0.2</easymock.version>
- <gmaven.version>1.8.0</gmaven.version>
- <groovy.version>3.0.3</groovy.version>
+ <mockito.version>3.7.0</mockito.version>
+ <gmaven.version>1.12.0</gmaven.version>
+ <groovy.version>3.0.7</groovy.version>
<junit.version>5.6.2</junit.version>
<junit.server.jetty.version>0.11.0</junit.server.jetty.version>
<hibernate.version>5.4.3.Final</hibernate.version>
@@ -185,9 +190,6 @@
<organization>Stormpath</organization>
<organizationUrl>https://www.stormpath.com</organizationUrl>
<timezone>-8</timezone>
- <roles>
- <role>PMC Chair</role>
- </roles>
</developer>
<developer>
<id>kaosko</id>
@@ -219,6 +221,9 @@
<organization>Stormpath</organization>
<organizationUrl>https://stormpath.com/</organizationUrl>
<timezone>-5</timezone>
+ <roles>
+ <role>PMC Chair</role>
+ </roles>
</developer>
<developer>
<id>jbunting</id>
@@ -259,7 +264,7 @@
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-war-plugin</artifactId>
- <version>3.2.2</version>
+ <version>3.3.1</version>
</plugin>
<plugin>
<groupId>org.apache.felix</groupId>
@@ -327,7 +332,7 @@
<plugin>
<groupId>org.jacoco</groupId>
<artifactId>jacoco-maven-plugin</artifactId>
- <version>0.8.4</version>
+ <version>0.8.6</version>
</plugin>
<plugin>
<groupId>com.mycila</groupId>
@@ -429,10 +434,12 @@
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
- <version>3.0.0-M3</version>
+ <version>3.0.0-M5</version>
<configuration>
- <printSummary>true</printSummary>
- <useSystemClassLoader>false</useSystemClassLoader>
+ <argLine>${surefire.argLine}</argLine>
+ <shutdown>kill</shutdown>
+ <enableProcessChecker>native</enableProcessChecker>
+ <trimStackTrace>false</trimStackTrace>
</configuration>
</plugin>
<plugin>
@@ -450,6 +457,7 @@
<exclude>**/*ManualIT.java</exclude>
<exclude>**/*ManualIT.groovy</exclude>
</excludes>
+ <argLine>${failsafe.argLine}</argLine>
</configuration>
<executions>
<execution>
@@ -690,6 +698,12 @@
<version>${easymock.version}</version>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.mockito</groupId>
+ <artifactId>mockito-core</artifactId>
+ <version>${mockito.version}</version>
+ <scope>test</scope>
+ </dependency>
<!-- Writing tests in groovy is fast!: -->
<dependency>
<groupId>org.codehaus.groovy</groupId>
@@ -1230,6 +1244,7 @@
<link>https://docs.spring.io/spring/docs/2.5.x/javadoc-api/</link>
<link>https://junit.org/junit4/javadoc/4.12/</link>
<link>http://easymock.org/api/easymock/2.4</link>
+ <link>https://javadoc.io/doc/org.mockito/mockito-core/${mockito.version}/org/mockito/Mockito.html</link>
<link>https://www.quartz-scheduler.org/api/1.8.6/</link>
</links>
<!-- Don't include the sample apps - they're not part of Shiro's API: -->
diff --git a/samples/guice/pom.xml b/samples/guice/pom.xml
index d1ee44d..f1bcaeb 100644
--- a/samples/guice/pom.xml
+++ b/samples/guice/pom.xml
@@ -113,4 +113,17 @@
</dependency>
</dependencies>
+ <profiles>
+ <profile>
+ <id>jdk16</id>
+ <activation>
+ <jdk>[16,)</jdk>
+ </activation>
+ <properties>
+ <!-- needed by guice until it is compatible with jdk16+. -->
+ <surefire.argLine>--illegal-access=permit</surefire.argLine>
+ <failsafe.argLine>--illegal-access=permit</failsafe.argLine>
+ </properties>
+ </profile>
+ </profiles>
</project>
diff --git a/samples/quickstart-guice/src/main/java/QuickstartGuice.java b/samples/quickstart-guice/src/main/java/QuickstartGuice.java
index 5fcb1e3..aabfc7e 100644
--- a/samples/quickstart-guice/src/main/java/QuickstartGuice.java
+++ b/samples/quickstart-guice/src/main/java/QuickstartGuice.java
@@ -96,7 +96,7 @@
}
//test a typed permission (not instance-level)
- if (currentUser.isPermitted("lightsaber:weild")) {
+ if (currentUser.isPermitted("lightsaber:wield")) {
log.info("You may use a lightsaber ring. Use it wisely.");
} else {
log.info("Sorry, lightsaber rings are for schwartz masters only.");
diff --git a/support/guice/pom.xml b/support/guice/pom.xml
index 7b2c50e..a1f866b 100644
--- a/support/guice/pom.xml
+++ b/support/guice/pom.xml
@@ -121,4 +121,17 @@
</plugin>
</plugins>
</build>
+
+ <profiles>
+ <profile>
+ <id>jdk16</id>
+ <activation>
+ <jdk>[16,)</jdk>
+ </activation>
+ <properties>
+ <!-- needed by guice until it is compatible with jdk16+. -->
+ <surefire.argLine>--illegal-access=permit</surefire.argLine>
+ </properties>
+ </profile>
+ </profiles>
</project>
diff --git a/support/guice/src/test/java/org/apache/shiro/guice/BeanTypeListenerTest.java b/support/guice/src/test/java/org/apache/shiro/guice/BeanTypeListenerTest.java
index 68e178d..421ae32 100644
--- a/support/guice/src/test/java/org/apache/shiro/guice/BeanTypeListenerTest.java
+++ b/support/guice/src/test/java/org/apache/shiro/guice/BeanTypeListenerTest.java
@@ -18,24 +18,33 @@
*/
package org.apache.shiro.guice;
-import com.google.inject.*;
+import com.google.inject.ConfigurationException;
+import com.google.inject.Injector;
+import com.google.inject.Key;
+import com.google.inject.MembersInjector;
+import com.google.inject.Provider;
+import com.google.inject.TypeLiteral;
import com.google.inject.name.Names;
import com.google.inject.spi.Message;
import com.google.inject.spi.TypeEncounter;
-import org.apache.shiro.guice.aop.ShiroAopModule;
-import org.apache.shiro.guice.web.ShiroWebModule;
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.aop.DefaultAnnotationResolver;
import org.apache.shiro.crypto.cipher.BlowfishCipherService;
-import org.easymock.Capture;
-import org.easymock.IMocksControl;
+import org.apache.shiro.guice.aop.ShiroAopModule;
+import org.apache.shiro.guice.web.ShiroWebModule;
import org.junit.Test;
+import org.mockito.ArgumentCaptor;
import java.util.Collections;
import java.util.Map;
-import static org.easymock.EasyMock.*;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
/**
* Test Cases::
@@ -64,29 +73,25 @@
@Test
public void testPropertySetting() throws Exception {
- IMocksControl control = createControl();
- TypeEncounter<SomeInjectableBean> encounter = control.createMock(TypeEncounter.class);
+ TypeEncounter<SomeInjectableBean> encounter = mock(TypeEncounter.class);
- Provider<Injector> injectorProvider = control.createMock(Provider.class);
- Injector injector = control.createMock(Injector.class);
+ Provider<Injector> injectorProvider = mock(Provider.class);
+ Injector injector = mock(Injector.class);
- expect(encounter.getProvider(Injector.class)).andReturn(injectorProvider);
+ when(encounter.getProvider(Injector.class)).then(args -> injectorProvider);
- expect(injectorProvider.get()).andReturn(injector).anyTimes();
+ when(injectorProvider.get()).then(args -> injector);
- Capture<MembersInjector<SomeInjectableBean>> capture = Capture.newInstance();
- encounter.register(and(anyObject(MembersInjector.class), capture(capture)));
+ ArgumentCaptor<MembersInjector<SomeInjectableBean>> captor = ArgumentCaptor.forClass(MembersInjector.class);
- SecurityManager securityManager = control.createMock(SecurityManager.class);
+ SecurityManager securityManager = mock(SecurityManager.class);
String property = "myPropertyValue";
- expect(injector.getInstance(Key.get(SecurityManager.class))).andReturn(securityManager);
- expect(injector.getInstance(Key.get(String.class, Names.named("shiro.myProperty")))).andReturn(property);
- expect(injector.getInstance(Key.get(String.class, Names.named("shiro.unavailableProperty"))))
- .andThrow(new ConfigurationException(Collections.singleton(new Message("Not Available!"))));
- expect((Map)injector.getInstance(BeanTypeListener.MAP_KEY)).andReturn(Collections.EMPTY_MAP).anyTimes();
-
- control.replay();
+ when(injector.getInstance(Key.get(SecurityManager.class))).then(args -> securityManager);
+ when(injector.getInstance(Key.get(String.class, Names.named("shiro.myProperty")))).then(args -> property);
+ when(injector.getInstance(Key.get(String.class, Names.named("shiro.unavailableProperty"))))
+ .thenThrow(new ConfigurationException(Collections.singleton(new Message("Not Available!"))));
+ when((Map) injector.getInstance(BeanTypeListener.MAP_KEY)).then(args -> Collections.EMPTY_MAP);
BeanTypeListener underTest = new BeanTypeListener();
@@ -94,13 +99,12 @@
SomeInjectableBean bean = new SomeInjectableBean();
- capture.getValue().injectMembers(bean);
+ verify(encounter).register(captor.capture());
+ captor.getValue().injectMembers(bean);
assertSame(securityManager, bean.securityManager);
assertSame(property, bean.myProperty);
assertNull(bean.unavailableProperty);
-
- control.verify();
}
public static class SomeInjectableBean {
diff --git a/support/hazelcast/src/test/groovy/org/apache/shiro/hazelcast/cache/HazelcastCacheManagerTest.groovy b/support/hazelcast/src/test/groovy/org/apache/shiro/hazelcast/cache/HazelcastCacheManagerTest.groovy
index e8901a2..937f405 100644
--- a/support/hazelcast/src/test/groovy/org/apache/shiro/hazelcast/cache/HazelcastCacheManagerTest.groovy
+++ b/support/hazelcast/src/test/groovy/org/apache/shiro/hazelcast/cache/HazelcastCacheManagerTest.groovy
@@ -23,8 +23,8 @@
import com.hazelcast.core.LifecycleService
import org.junit.Test
-import static org.easymock.EasyMock.*
import static org.junit.Assert.*
+import static org.mockito.Mockito.*
/**
* Unit tests for {@link HazelcastCacheManager}.
@@ -40,15 +40,11 @@
HazelcastInstance hc = mock(HazelcastInstance)
def manager = new HazelcastCacheManager();
- replay hc
-
// when
manager.hazelcastInstance = hc
// then
assertSame hc, manager.hazelcastInstance
-
- verify hc
}
@Test
@@ -69,35 +65,31 @@
void testImplicitlyCreated() {
// given
- HazelcastInstance hazelcastInstance = niceMock(HazelcastInstance)
+ HazelcastInstance hazelcastInstance = mock(HazelcastInstance)
- HazelcastCacheManager manager = createMockBuilder(HazelcastCacheManager)
- .addMockedMethod("createHazelcastInstance")
- .niceMock();
- expect(manager.createHazelcastInstance()).andReturn(hazelcastInstance)
+ HazelcastCacheManager manager = spy(HazelcastCacheManager);
+ when(manager.createHazelcastInstance()).then(args -> hazelcastInstance)
// when
manager.init()
// then
assertTrue manager.implicitlyCreated
+ manager.destroy()
}
@Test
void testDestroy() {
// given
- LifecycleService lifecycleService = niceMock(LifecycleService)
+ LifecycleService lifecycleService = mock(LifecycleService)
- HazelcastInstance hazelcastInstance = niceMock(HazelcastInstance)
- expect(hazelcastInstance.getLifecycleService()).andReturn(lifecycleService)
+ HazelcastInstance hazelcastInstance = spy(HazelcastInstance)
+ when(hazelcastInstance.getLifecycleService()).then(args -> lifecycleService)
- HazelcastCacheManager manager = createMockBuilder(HazelcastCacheManager)
- .addMockedMethod("createHazelcastInstance")
- .niceMock();
- expect(manager.createHazelcastInstance()).andReturn(hazelcastInstance)
+ HazelcastCacheManager manager = spy(HazelcastCacheManager);
+ when(manager.createHazelcastInstance()).then(args -> hazelcastInstance)
- replay lifecycleService, hazelcastInstance, manager
// when
manager.init()
@@ -106,20 +98,18 @@
// then
assertFalse manager.implicitlyCreated
assertNull manager.hazelcastInstance
- verify hazelcastInstance
- verify manager
+ verify(hazelcastInstance).getLifecycleService()
+ verify(manager).createHazelcastInstance()
}
@Test
void testDestroyExplicit() {
// given
- HazelcastInstance hazelcastInstance = niceMock(HazelcastInstance)
+ HazelcastInstance hazelcastInstance = mock(HazelcastInstance)
HazelcastCacheManager manager = new HazelcastCacheManager()
manager.hazelcastInstance = hazelcastInstance
- replay hazelcastInstance
-
// when
manager.init()
manager.destroy()
@@ -134,17 +124,13 @@
// given
LifecycleService lifecycleService = mock(LifecycleService)
- expect(lifecycleService.shutdown()).andThrow(new IllegalStateException())
+ when(lifecycleService.shutdown()).thenThrow(new IllegalStateException())
HazelcastInstance hazelcastInstance = mock(HazelcastInstance)
- expect(hazelcastInstance.getLifecycleService()).andReturn(lifecycleService)
+ when(hazelcastInstance.getLifecycleService()).then(args -> lifecycleService)
- HazelcastCacheManager manager = createMockBuilder(HazelcastCacheManager)
- .addMockedMethod("createHazelcastInstance")
- .niceMock();
- expect(manager.createHazelcastInstance()).andReturn(hazelcastInstance)
-
- replay lifecycleService, hazelcastInstance, manager
+ HazelcastCacheManager manager = spy(HazelcastCacheManager);
+ when(manager.createHazelcastInstance()).then(args -> hazelcastInstance)
// when
manager.init()
@@ -152,9 +138,9 @@
// then
assertFalse manager.implicitlyCreated
- verify lifecycleService
- verify hazelcastInstance
- verify manager
+ verify(lifecycleService).shutdown()
+ verify(hazelcastInstance).getLifecycleService()
+ verify(manager).createHazelcastInstance()
}
}
diff --git a/support/jaxrs/pom.xml b/support/jaxrs/pom.xml
index c7ee487..20f6d0b 100644
--- a/support/jaxrs/pom.xml
+++ b/support/jaxrs/pom.xml
@@ -57,6 +57,12 @@
<artifactId>jcl-over-slf4j</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>javax.xml.bind</groupId>
+ <artifactId>jaxb-api</artifactId>
+ <version>2.3.1</version>
+ <scope>test</scope>
+ </dependency>
</dependencies>
<build>
diff --git a/support/jaxrs/src/test/groovy/org/apache/shiro/web/jaxrs/ExceptionMapperTest.groovy b/support/jaxrs/src/test/groovy/org/apache/shiro/web/jaxrs/ExceptionMapperTest.groovy
index 8aa3c18..f42fbd6 100644
--- a/support/jaxrs/src/test/groovy/org/apache/shiro/web/jaxrs/ExceptionMapperTest.groovy
+++ b/support/jaxrs/src/test/groovy/org/apache/shiro/web/jaxrs/ExceptionMapperTest.groovy
@@ -25,8 +25,8 @@
import javax.ws.rs.core.Response
import javax.ws.rs.ext.RuntimeDelegate
-import static org.junit.Assert.*
-import static org.easymock.EasyMock.*
+import static org.junit.Assert.assertSame
+import static org.mockito.Mockito.*
/**
* Tests for {@link ExceptionMapper}.
@@ -43,22 +43,22 @@
}
private void doTest(AuthorizationException exception , Response.StatusType expectedStatus) {
- def runtimeDelegate = strictMock(RuntimeDelegate)
+ def runtimeDelegate = mock(RuntimeDelegate)
RuntimeDelegate.setInstance(runtimeDelegate)
- def responseBuilder = strictMock(Response.ResponseBuilder)
- def response = strictMock(Response)
+ def responseBuilder = mock(Response.ResponseBuilder)
+ def response = mock(Response)
- expect(runtimeDelegate.createResponseBuilder()).andReturn(responseBuilder).anyTimes()
- expect(responseBuilder.status((Response.StatusType) expectedStatus)).andReturn(responseBuilder)
- expect(responseBuilder.build()).andReturn(response)
-
- replay runtimeDelegate, responseBuilder
+ when(runtimeDelegate.createResponseBuilder()).then(args -> responseBuilder)
+ when(responseBuilder.status((Response.StatusType) expectedStatus)).then(args -> responseBuilder)
+ when(responseBuilder.build()).then(args -> response)
def responseResult = new ExceptionMapper().toResponse(exception)
assertSame response, responseResult
- verify runtimeDelegate, responseBuilder
+ verify(runtimeDelegate).createResponseBuilder()
+ verify(responseBuilder).status((Response.StatusType) expectedStatus)
+ verify(responseBuilder).build()
}
}
diff --git a/support/spring/src/test/groovy/org/apache/shiro/spring/config/ShiroEventBusAwareBeanPostProcessorTest.groovy b/support/spring/src/test/groovy/org/apache/shiro/spring/config/ShiroEventBusAwareBeanPostProcessorTest.groovy
index b4224a1..297e1ce 100644
--- a/support/spring/src/test/groovy/org/apache/shiro/spring/config/ShiroEventBusAwareBeanPostProcessorTest.groovy
+++ b/support/spring/src/test/groovy/org/apache/shiro/spring/config/ShiroEventBusAwareBeanPostProcessorTest.groovy
@@ -24,7 +24,7 @@
import org.junit.Assert
import org.junit.Test
-import static org.easymock.EasyMock.*
+import static org.mockito.Mockito.mock
/**
* Tests for {@link org.apache.shiro.spring.ShiroEventBusBeanPostProcessor}
@@ -34,16 +34,13 @@
@Test
void testPostConstructNonAware() {
- def eventBus = createStrictMock(EventBus)
- def bean = createStrictMock(Object)
-
- replay eventBus, bean
+ def eventBus = mock(EventBus)
+ def bean = mock(Object)
def postProcessor = new ShiroEventBusBeanPostProcessor(eventBus);
def resultAfter = postProcessor.postProcessAfterInitialization(bean, "bean")
def resultBefore = postProcessor.postProcessBeforeInitialization(bean, "bean")
- verify eventBus, bean
Assert.assertSame resultAfter, bean
Assert.assertSame resultBefore, bean
}
@@ -51,17 +48,14 @@
@Test
void testPostConstructWithEventBusAware() {
- def eventBus = createStrictMock(EventBus)
- def bean = createStrictMock(EventBusAware)
+ def eventBus = mock(EventBus)
+ def bean = mock(EventBusAware)
bean.eventBus = eventBus
- replay eventBus, bean
-
def postProcessor = new ShiroEventBusBeanPostProcessor(eventBus);
def resultAfter = postProcessor.postProcessAfterInitialization(bean, "bean")
def resultBefore = postProcessor.postProcessBeforeInitialization(bean, "bean")
- verify eventBus, bean
Assert.assertSame resultAfter, bean
Assert.assertSame resultBefore, bean
}
diff --git a/support/spring/src/test/groovy/org/apache/shiro/spring/web/config/ShiroWebConfigurationWithCacheTest.groovy b/support/spring/src/test/groovy/org/apache/shiro/spring/web/config/ShiroWebConfigurationWithCacheTest.groovy
index 9cb77e7..4630057 100644
--- a/support/spring/src/test/groovy/org/apache/shiro/spring/web/config/ShiroWebConfigurationWithCacheTest.groovy
+++ b/support/spring/src/test/groovy/org/apache/shiro/spring/web/config/ShiroWebConfigurationWithCacheTest.groovy
@@ -20,20 +20,14 @@
import org.apache.shiro.mgt.SecurityManager
import org.apache.shiro.realm.text.TextConfigurationRealm
-import org.apache.shiro.spring.config.EventBusTestConfiguration
-import org.apache.shiro.spring.config.RealmTestConfiguration
-import org.apache.shiro.spring.config.ShiroAnnotationProcessorConfiguration
-import org.apache.shiro.spring.security.interceptor.AuthorizationAttributeSourceAdvisor
import org.apache.shiro.spring.testconfig.EventBusTestConfiguration
import org.apache.shiro.spring.testconfig.RealmTestConfiguration
import org.apache.shiro.spring.web.testconfig.CacheManagerConfiguration
-
import org.junit.Assert
import org.junit.Test
import org.junit.runner.RunWith
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.test.context.ContextConfiguration
-import org.springframework.test.context.junit4.AbstractJUnit4SpringContextTests
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner
import static org.hamcrest.MatcherAssert.assertThat
diff --git a/web/src/main/java/org/apache/shiro/web/filter/PathMatchingFilter.java b/web/src/main/java/org/apache/shiro/web/filter/PathMatchingFilter.java
index 7d4df31..11eec59 100644
--- a/web/src/main/java/org/apache/shiro/web/filter/PathMatchingFilter.java
+++ b/web/src/main/java/org/apache/shiro/web/filter/PathMatchingFilter.java
@@ -122,16 +122,24 @@
*/
protected boolean pathsMatch(String path, ServletRequest request) {
String requestURI = getPathWithinApplication(request);
- if (requestURI != null && !DEFAULT_PATH_SEPARATOR.equals(requestURI)
- && requestURI.endsWith(DEFAULT_PATH_SEPARATOR)) {
- requestURI = requestURI.substring(0, requestURI.length() - 1);
- }
- if (path != null && !DEFAULT_PATH_SEPARATOR.equals(path)
- && path.endsWith(DEFAULT_PATH_SEPARATOR)) {
- path = path.substring(0, path.length() - 1);
- }
+
log.trace("Attempting to match pattern '{}' with current requestURI '{}'...", path, Encode.forHtml(requestURI));
- return pathsMatch(path, requestURI);
+ boolean match = pathsMatch(path, requestURI);
+
+ if (!match) {
+ if (requestURI != null && !DEFAULT_PATH_SEPARATOR.equals(requestURI)
+ && requestURI.endsWith(DEFAULT_PATH_SEPARATOR)) {
+ requestURI = requestURI.substring(0, requestURI.length() - 1);
+ }
+ if (path != null && !DEFAULT_PATH_SEPARATOR.equals(path)
+ && path.endsWith(DEFAULT_PATH_SEPARATOR)) {
+ path = path.substring(0, path.length() - 1);
+ }
+ log.trace("Attempting to match pattern '{}' with current requestURI '{}'...", path, Encode.forHtml(requestURI));
+ match = pathsMatch(path, requestURI);
+ }
+
+ return match;
}
/**
@@ -148,7 +156,9 @@
* <code>false</code> otherwise.
*/
protected boolean pathsMatch(String pattern, String path) {
- return pathMatcher.matches(pattern, path);
+ boolean matches = pathMatcher.matches(pattern, path);
+ log.trace("Pattern [{}] matches path [{}] => [{}]", pattern, path, matches);
+ return matches;
}
/**
diff --git a/web/src/main/java/org/apache/shiro/web/filter/authc/BasicHttpAuthenticationFilter.java b/web/src/main/java/org/apache/shiro/web/filter/authc/BasicHttpAuthenticationFilter.java
index 015e692..6b0c08c 100644
--- a/web/src/main/java/org/apache/shiro/web/filter/authc/BasicHttpAuthenticationFilter.java
+++ b/web/src/main/java/org/apache/shiro/web/filter/authc/BasicHttpAuthenticationFilter.java
@@ -82,9 +82,10 @@
* </ol>
*
* @param request incoming ServletRequest
- * @param response outgoing ServletResponse
+ * @param response outgoing ServletResponse (never used)
* @return the AuthenticationToken used to execute the login attempt
*/
+ @Override
protected AuthenticationToken createToken(ServletRequest request, ServletResponse response) {
String authorizationHeader = getAuthzHeader(request);
if (authorizationHeader == null || authorizationHeader.length() == 0) {
@@ -125,6 +126,7 @@
* @param encoded the Base64-encoded username:password value found after the scheme in the header
* @return the username (index 0)/password (index 1) pair obtained from the encoded header data.
*/
+ @Override
protected String[] getPrincipalsAndCredentials(String scheme, String encoded) {
String decoded = Base64.decodeToString(encoded);
return decoded.split(":", 2);
diff --git a/web/src/main/java/org/apache/shiro/web/filter/mgt/PathMatchingFilterChainResolver.java b/web/src/main/java/org/apache/shiro/web/filter/mgt/PathMatchingFilterChainResolver.java
index 7583060..6d81e02 100644
--- a/web/src/main/java/org/apache/shiro/web/filter/mgt/PathMatchingFilterChainResolver.java
+++ b/web/src/main/java/org/apache/shiro/web/filter/mgt/PathMatchingFilterChainResolver.java
@@ -99,32 +99,34 @@
return null;
}
- String requestURI = getPathWithinApplication(request);
-
- // in spring web, the requestURI "/resource/menus" ---- "resource/menus/" bose can access the resource
- // but the pathPattern match "/resource/menus" can not match "resource/menus/"
- // user can use requestURI + "/" to simply bypassed chain filter, to bypassed shiro protect
- if(requestURI != null && !DEFAULT_PATH_SEPARATOR.equals(requestURI)
- && requestURI.endsWith(DEFAULT_PATH_SEPARATOR)) {
- requestURI = requestURI.substring(0, requestURI.length() - 1);
- }
-
+ final String requestURI = getPathWithinApplication(request);
+ final String requestURINoTrailingSlash = removeTrailingSlash(requestURI);
//the 'chain names' in this implementation are actually path patterns defined by the user. We just use them
//as the chain name for the FilterChainManager's requirements
for (String pathPattern : filterChainManager.getChainNames()) {
- if (pathPattern != null && !DEFAULT_PATH_SEPARATOR.equals(pathPattern)
- && pathPattern.endsWith(DEFAULT_PATH_SEPARATOR)) {
- pathPattern = pathPattern.substring(0, pathPattern.length() - 1);
- }
-
// If the path does match, then pass on to the subclass implementation for specific checks:
if (pathMatches(pathPattern, requestURI)) {
if (log.isTraceEnabled()) {
- log.trace("Matched path pattern [" + pathPattern + "] for requestURI [" + Encode.forHtml(requestURI) + "]. " +
- "Utilizing corresponding filter chain...");
+ log.trace("Matched path pattern [{}] for requestURI [{}]. " +
+ "Utilizing corresponding filter chain...", pathPattern, Encode.forHtml(requestURI));
}
return filterChainManager.proxy(originalChain, pathPattern);
+ } else {
+
+ // in spring web, the requestURI "/resource/menus" ---- "resource/menus/" bose can access the resource
+ // but the pathPattern match "/resource/menus" can not match "resource/menus/"
+ // user can use requestURI + "/" to simply bypassed chain filter, to bypassed shiro protect
+
+ pathPattern = removeTrailingSlash(pathPattern);
+
+ if (pathMatches(pathPattern, requestURINoTrailingSlash)) {
+ if (log.isTraceEnabled()) {
+ log.trace("Matched path pattern [{}] for requestURI [{}]. " +
+ "Utilizing corresponding filter chain...", pathPattern, Encode.forHtml(requestURINoTrailingSlash));
+ }
+ return filterChainManager.proxy(originalChain, requestURINoTrailingSlash);
+ }
}
}
@@ -162,4 +164,12 @@
protected String getPathWithinApplication(ServletRequest request) {
return WebUtils.getPathWithinApplication(WebUtils.toHttp(request));
}
+
+ private static String removeTrailingSlash(String path) {
+ if(path != null && !DEFAULT_PATH_SEPARATOR.equals(path)
+ && path.endsWith(DEFAULT_PATH_SEPARATOR)) {
+ return path.substring(0, path.length() - 1);
+ }
+ return path;
+ }
}
diff --git a/web/src/main/java/org/apache/shiro/web/session/HttpServletSession.java b/web/src/main/java/org/apache/shiro/web/session/HttpServletSession.java
index 4acab37..0f39eb5 100644
--- a/web/src/main/java/org/apache/shiro/web/session/HttpServletSession.java
+++ b/web/src/main/java/org/apache/shiro/web/session/HttpServletSession.java
@@ -83,7 +83,7 @@
public void setTimeout(long maxIdleTimeInMillis) throws InvalidSessionException {
try {
- int timeout = Long.valueOf(maxIdleTimeInMillis / 1000).intValue();
+ int timeout = (int) (maxIdleTimeInMillis / 1000);
httpSession.setMaxInactiveInterval(timeout);
} catch (Exception e) {
throw new InvalidSessionException(e);
diff --git a/web/src/test/groovy/org/apache/shiro/web/filter/authc/BearerHttpFilterAuthenticationTest.groovy b/web/src/test/groovy/org/apache/shiro/web/filter/authc/BearerHttpFilterAuthenticationTest.groovy
index bb8a1ff..ac7ffea 100644
--- a/web/src/test/groovy/org/apache/shiro/web/filter/authc/BearerHttpFilterAuthenticationTest.groovy
+++ b/web/src/test/groovy/org/apache/shiro/web/filter/authc/BearerHttpFilterAuthenticationTest.groovy
@@ -18,21 +18,17 @@
*/
package org.apache.shiro.web.filter.authc
-import org.apache.shiro.authc.BearerToken
import org.apache.shiro.authc.AuthenticationToken
+import org.apache.shiro.authc.BearerToken
import org.apache.shiro.test.SecurityManagerTestSupport
import org.hamcrest.CoreMatchers
import org.hamcrest.Matchers
-import org.junit.Test
+import org.junit.jupiter.api.Test
import javax.servlet.http.HttpServletRequest
import javax.servlet.http.HttpServletResponse
-import static org.easymock.EasyMock.createMock
-import static org.easymock.EasyMock.expect
-import static org.easymock.EasyMock.replay
-import static org.easymock.EasyMock.verify
-
+import static org.easymock.EasyMock.*
import static org.hamcrest.MatcherAssert.assertThat
/**
diff --git a/web/src/test/groovy/org/apache/shiro/web/servlet/ShiroHttpServletResponseTest.groovy b/web/src/test/groovy/org/apache/shiro/web/servlet/ShiroHttpServletResponseTest.groovy
index a26dca7..af23404 100644
--- a/web/src/test/groovy/org/apache/shiro/web/servlet/ShiroHttpServletResponseTest.groovy
+++ b/web/src/test/groovy/org/apache/shiro/web/servlet/ShiroHttpServletResponseTest.groovy
@@ -24,8 +24,8 @@
import javax.servlet.http.HttpServletResponse
import javax.servlet.http.HttpSession
-import static org.easymock.EasyMock.*
-import static org.junit.Assert.*
+import static org.junit.Assert.assertEquals
+import static org.mockito.Mockito.*
/**
* Unit tests for {@link ShiroHttpServletResponse}.
@@ -37,69 +37,70 @@
@Test
void testEncodeURLNoSessionId() {
- def servletContext = createStrictMock(ServletContext)
- def httpServletResponse = createStrictMock(HttpServletResponse)
+ def servletContext = mock(ServletContext)
+ def httpServletResponse = mock(HttpServletResponse)
def shiroHttpServletRequest = setupRequestMock()
- expect(shiroHttpServletRequest.getSession(false)).andReturn(null)
- expect(shiroHttpServletRequest.getAttribute(ShiroHttpServletRequest.SESSION_ID_URL_REWRITING_ENABLED)).andReturn(true)
- replay shiroHttpServletRequest, servletContext, httpServletResponse
+ when(shiroHttpServletRequest.getSession(false)).then(args -> null)
+ when(shiroHttpServletRequest.getAttribute(ShiroHttpServletRequest.SESSION_ID_URL_REWRITING_ENABLED)).then(args -> true)
def shiroHttpServletResponse = new ShiroHttpServletResponse(httpServletResponse, servletContext, shiroHttpServletRequest)
assertEquals "/foobar", shiroHttpServletResponse.encodeURL("/foobar")
- verify shiroHttpServletRequest, servletContext, httpServletResponse
+ verify(shiroHttpServletRequest).getSession(false)
+ verify(shiroHttpServletRequest).getAttribute(ShiroHttpServletRequest.SESSION_ID_URL_REWRITING_ENABLED)
}
@Test
void testEncodeURLSessionIdInURL() {
- def servletContext = createStrictMock(ServletContext)
- def httpServletResponse = createStrictMock(HttpServletResponse)
- def session = createMock(HttpSession)
+ def servletContext = mock(ServletContext)
+ def httpServletResponse = mock(HttpServletResponse)
+ def session = mock(HttpSession)
def shiroHttpServletRequest = setupRequestMock()
- expect(session.getId()).andReturn(URL_SESSION_ID).anyTimes()
- expect(shiroHttpServletRequest.getSession(false)).andReturn(session)
- expect(shiroHttpServletRequest.getSession()).andReturn(session)
- expect(shiroHttpServletRequest.isRequestedSessionIdFromCookie()).andReturn(false)
- expect(shiroHttpServletRequest.getAttribute(ShiroHttpServletRequest.SESSION_ID_URL_REWRITING_ENABLED)).andReturn(true)
- replay shiroHttpServletRequest, servletContext, httpServletResponse, session
+ when(session.getId()).then(args -> URL_SESSION_ID)
+ when(shiroHttpServletRequest.getSession(false)).then(args -> session)
+ when(shiroHttpServletRequest.getSession()).then(args -> session)
+ when(shiroHttpServletRequest.isRequestedSessionIdFromCookie()).then(args -> false)
+ when(shiroHttpServletRequest.getAttribute(ShiroHttpServletRequest.SESSION_ID_URL_REWRITING_ENABLED)).then(args -> true)
def shiroHttpServletResponse = new ShiroHttpServletResponse(httpServletResponse, servletContext, shiroHttpServletRequest)
assertEquals "/foobar;JSESSIONID=" + URL_SESSION_ID, shiroHttpServletResponse.encodeURL("/foobar")
- verify shiroHttpServletRequest, servletContext, httpServletResponse, session
+ verify(shiroHttpServletRequest).getSession(false)
+ verify(shiroHttpServletRequest).getSession()
+ verify(shiroHttpServletRequest).isRequestedSessionIdFromCookie()
+ verify(shiroHttpServletRequest).getAttribute(ShiroHttpServletRequest.SESSION_ID_URL_REWRITING_ENABLED)
+ verify(session, times(2)).getId()
}
@Test
void testEncodeURLSessionIdInCookie() {
- def servletContext = createStrictMock(ServletContext)
- def httpServletResponse = createStrictMock(HttpServletResponse)
- def session = createMock(HttpSession)
+ def servletContext = mock(ServletContext)
+ def httpServletResponse = mock(HttpServletResponse)
+ def session = mock(HttpSession)
def shiroHttpServletRequest = setupRequestMock()
- expect(shiroHttpServletRequest.getAttribute(ShiroHttpServletRequest.SESSION_ID_URL_REWRITING_ENABLED)).andReturn(false)
- replay shiroHttpServletRequest, servletContext, httpServletResponse, session
+ when(shiroHttpServletRequest.getAttribute(ShiroHttpServletRequest.SESSION_ID_URL_REWRITING_ENABLED)).then(args -> false)
def shiroHttpServletResponse = new ShiroHttpServletResponse(httpServletResponse, servletContext, shiroHttpServletRequest)
assertEquals "/foobar", shiroHttpServletResponse.encodeURL("/foobar")
- verify shiroHttpServletRequest, servletContext, httpServletResponse, session
+ verify(shiroHttpServletRequest).getAttribute(ShiroHttpServletRequest.SESSION_ID_URL_REWRITING_ENABLED)
}
@Test
void testEncodeURLSessionIdInWhenRewriteDisabled() {
- def servletContext = createStrictMock(ServletContext)
- def httpServletResponse = createStrictMock(HttpServletResponse)
- def session = createMock(HttpSession)
+ def servletContext = mock(ServletContext)
+ def httpServletResponse = mock(HttpServletResponse)
+ def session = mock(HttpSession)
def shiroHttpServletRequest = setupRequestMock()
- expect(shiroHttpServletRequest.getAttribute(ShiroHttpServletRequest.SESSION_ID_URL_REWRITING_ENABLED)).andReturn(false)
- replay shiroHttpServletRequest, servletContext, httpServletResponse, session
+ when(shiroHttpServletRequest.getAttribute(ShiroHttpServletRequest.SESSION_ID_URL_REWRITING_ENABLED)).then(args -> false)
def shiroHttpServletResponse = new ShiroHttpServletResponse(httpServletResponse, servletContext, shiroHttpServletRequest)
assertEquals "/foobar", shiroHttpServletResponse.encodeURL("/foobar")
- verify shiroHttpServletRequest, servletContext, httpServletResponse, session
+ verify(shiroHttpServletRequest).getAttribute(ShiroHttpServletRequest.SESSION_ID_URL_REWRITING_ENABLED)
}
/**
@@ -109,21 +110,24 @@
@Test
void testEncodeURLSessionIdInWhenRewriteInvalid() {
- def servletContext = createStrictMock(ServletContext)
- def httpServletResponse = createStrictMock(HttpServletResponse)
- def session = createMock(HttpSession)
+ def servletContext = mock(ServletContext)
+ def httpServletResponse = mock(HttpServletResponse)
+ def session = mock(HttpSession)
def shiroHttpServletRequest = setupRequestMock()
- expect(session.getId()).andReturn(URL_SESSION_ID).anyTimes()
- expect(shiroHttpServletRequest.getSession(false)).andReturn(session)
- expect(shiroHttpServletRequest.getSession()).andReturn(session)
- expect(shiroHttpServletRequest.isRequestedSessionIdFromCookie()).andReturn(false)
- expect(shiroHttpServletRequest.getAttribute(ShiroHttpServletRequest.SESSION_ID_URL_REWRITING_ENABLED)).andReturn("something-else")
- replay shiroHttpServletRequest, servletContext, httpServletResponse, session
+ when(session.getId()).then(args -> URL_SESSION_ID)
+ when(shiroHttpServletRequest.getSession(false)).then(args -> session)
+ when(shiroHttpServletRequest.getSession()).then(args -> session)
+ when(shiroHttpServletRequest.isRequestedSessionIdFromCookie()).then(args -> false)
+ when(shiroHttpServletRequest.getAttribute(ShiroHttpServletRequest.SESSION_ID_URL_REWRITING_ENABLED)).then(args -> "something-else")
def shiroHttpServletResponse = new ShiroHttpServletResponse(httpServletResponse, servletContext, shiroHttpServletRequest)
assertEquals "/foobar;JSESSIONID=" + URL_SESSION_ID, shiroHttpServletResponse.encodeURL("/foobar")
- verify shiroHttpServletRequest, servletContext, httpServletResponse, session
+ verify(shiroHttpServletRequest).getSession(false)
+ verify(shiroHttpServletRequest).getSession()
+ verify(shiroHttpServletRequest).isRequestedSessionIdFromCookie()
+ verify(shiroHttpServletRequest).getAttribute(ShiroHttpServletRequest.SESSION_ID_URL_REWRITING_ENABLED)
+ verify(session, times(2)).getId()
}
/**
@@ -133,32 +137,34 @@
@Test
void testEncodeURLSessionIdInWhenRewriteInvalidAndNull() {
- def servletContext = createStrictMock(ServletContext)
- def httpServletResponse = createStrictMock(HttpServletResponse)
- def session = createMock(HttpSession)
+ def servletContext = mock(ServletContext)
+ def httpServletResponse = mock(HttpServletResponse)
+ def session = mock(HttpSession)
def shiroHttpServletRequest = setupRequestMock()
- expect(session.getId()).andReturn(URL_SESSION_ID).anyTimes()
- expect(shiroHttpServletRequest.getSession(false)).andReturn(session)
- expect(shiroHttpServletRequest.getSession()).andReturn(session)
- expect(shiroHttpServletRequest.isRequestedSessionIdFromCookie()).andReturn(false)
- expect(shiroHttpServletRequest.getAttribute(ShiroHttpServletRequest.SESSION_ID_URL_REWRITING_ENABLED)).andReturn(null)
- replay shiroHttpServletRequest, servletContext, httpServletResponse, session
+ when(session.getId()).then(args -> URL_SESSION_ID)
+ when(shiroHttpServletRequest.getSession(false)).then(args -> session)
+ when(shiroHttpServletRequest.getSession()).then(args -> session)
+ when(shiroHttpServletRequest.isRequestedSessionIdFromCookie()).then(args -> false)
+ when(shiroHttpServletRequest.getAttribute(ShiroHttpServletRequest.SESSION_ID_URL_REWRITING_ENABLED)).then(args -> null)
def shiroHttpServletResponse = new ShiroHttpServletResponse(httpServletResponse, servletContext, shiroHttpServletRequest)
assertEquals "/foobar;JSESSIONID=" + URL_SESSION_ID, shiroHttpServletResponse.encodeURL("/foobar")
- verify shiroHttpServletRequest, servletContext, httpServletResponse, session
+ verify(shiroHttpServletRequest).getSession(false)
+ verify(shiroHttpServletRequest).getSession()
+ verify(shiroHttpServletRequest).isRequestedSessionIdFromCookie()
+ verify(shiroHttpServletRequest).getAttribute(ShiroHttpServletRequest.SESSION_ID_URL_REWRITING_ENABLED)
+ verify(session, times(2)).getId()
}
private static ShiroHttpServletRequest setupRequestMock() {
- def shiroHttpServletRequest = createMock(ShiroHttpServletRequest)
+ def shiroHttpServletRequest = mock(ShiroHttpServletRequest)
- expect(shiroHttpServletRequest.getScheme()).andReturn("http").anyTimes()
- expect(shiroHttpServletRequest.getServerName()).andReturn("localhost").anyTimes()
- expect(shiroHttpServletRequest.getServerPort()).andReturn(8080).anyTimes()
- expect(shiroHttpServletRequest.getContextPath()).andReturn("/").anyTimes()
-
+ when(shiroHttpServletRequest.getScheme()).then(args -> "http")
+ when(shiroHttpServletRequest.getServerName()).then(args -> "localhost")
+ when(shiroHttpServletRequest.getServerPort()).then(args -> 8080)
+ when(shiroHttpServletRequest.getContextPath()).then(args -> "/")
return shiroHttpServletRequest
}
diff --git a/web/src/test/java/org/apache/shiro/web/WebTest.java b/web/src/test/java/org/apache/shiro/web/WebTest.java
index 22eeacc..25ced2f 100644
--- a/web/src/test/java/org/apache/shiro/web/WebTest.java
+++ b/web/src/test/java/org/apache/shiro/web/WebTest.java
@@ -18,21 +18,21 @@
*/
package org.apache.shiro.web;
-import static org.easymock.EasyMock.createNiceMock;
-import static org.easymock.EasyMock.expect;
-
import javax.servlet.FilterConfig;
import javax.servlet.ServletContext;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
/**
* @since 1.0
*/
public abstract class WebTest {
protected FilterConfig createNiceMockFilterConfig() {
- FilterConfig mock = createNiceMock(FilterConfig.class);
- ServletContext mockServletContext = createNiceMock(ServletContext.class);
- expect(mock.getServletContext()).andReturn(mockServletContext);
+ FilterConfig mock = mock(FilterConfig.class);
+ ServletContext mockServletContext = mock(ServletContext.class);
+ when(mock.getServletContext()).thenReturn(mockServletContext);
return mock;
}
diff --git a/web/src/test/java/org/apache/shiro/web/env/EnvironmentLoaderServiceTest.java b/web/src/test/java/org/apache/shiro/web/env/EnvironmentLoaderServiceTest.java
index 250370a..9a45d20 100644
--- a/web/src/test/java/org/apache/shiro/web/env/EnvironmentLoaderServiceTest.java
+++ b/web/src/test/java/org/apache/shiro/web/env/EnvironmentLoaderServiceTest.java
@@ -28,8 +28,14 @@
import java.util.List;
import static org.easymock.EasyMock.expect;
-import static org.hamcrest.Matchers.*;
-import static org.hamcrest.MatcherAssert.*;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.sameInstance;
+import static org.hamcrest.Matchers.stringContainsInOrder;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
/**
* Tests for {@link EnvironmentLoader} which will use a ServiceLoader.
@@ -62,27 +68,21 @@
List<WebEnvironment> environmentList = Arrays.asList(new WebEnvironmentStub(), new WebEnvironmentStub());
- ServletContext servletContext = EasyMock.mock(ServletContext.class);
- expect(servletContext.getInitParameter(EnvironmentLoader.ENVIRONMENT_CLASS_PARAM)).andReturn(null);
+ ServletContext servletContext = mock(ServletContext.class);
+ when(servletContext.getInitParameter(EnvironmentLoader.ENVIRONMENT_CLASS_PARAM)).then(args -> null);
- EasyMock.replay(servletContext);
-
- final EnvironmentLoader environmentLoader = EasyMock.createMockBuilder(EnvironmentLoader.class)
- .addMockedMethod("doLoadWebEnvironmentsFromServiceLoader")
- .createMock();
- EasyMock.expect(environmentLoader.doLoadWebEnvironmentsFromServiceLoader()).andReturn(environmentList.iterator());
- EasyMock.replay(environmentLoader);
+ final EnvironmentLoader environmentLoader = spy(EnvironmentLoader.class);
+ when(environmentLoader.doLoadWebEnvironmentsFromServiceLoader()).then(args -> environmentList.iterator());
try {
environmentLoader.createEnvironment(servletContext);
Assert.fail("Expected ConfigurationException to be thrown");
- }
- catch (ConfigurationException e) {
+ } catch (ConfigurationException e) {
assertThat(e.getMessage(), stringContainsInOrder("zero or exactly one", "shiroEnvironmentClass"));
}
- EasyMock.verify(servletContext);
- EasyMock.verify(environmentLoader);
+ verify(servletContext).getInitParameter(EnvironmentLoader.ENVIRONMENT_CLASS_PARAM);
+ verify(environmentLoader).doLoadWebEnvironmentsFromServiceLoader();
}
@Test()
diff --git a/web/src/test/java/org/apache/shiro/web/filter/PathMatchingFilterParameterizedTest.java b/web/src/test/java/org/apache/shiro/web/filter/PathMatchingFilterParameterizedTest.java
new file mode 100644
index 0000000..82720ad
--- /dev/null
+++ b/web/src/test/java/org/apache/shiro/web/filter/PathMatchingFilterParameterizedTest.java
@@ -0,0 +1,150 @@
+/*
+ * 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.shiro.web.filter;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.Parameterized;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import javax.servlet.ServletRequest;
+import javax.servlet.ServletResponse;
+import javax.servlet.http.HttpServletRequest;
+
+import java.util.stream.Stream;
+
+import static org.easymock.EasyMock.createNiceMock;
+import static org.easymock.EasyMock.expect;
+import static org.easymock.EasyMock.replay;
+import static org.easymock.EasyMock.verify;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+/**
+ * Unit tests for the {@link PathMatchingFilter} implementation.
+ */
+@RunWith(Parameterized.class)
+public class PathMatchingFilterParameterizedTest {
+
+ private static final Logger LOG = LoggerFactory.getLogger(PathMatchingFilterParameterizedTest.class);
+
+ private static final String CONTEXT_PATH = "/";
+ private static final String DISABLED_PATH = CONTEXT_PATH + "disabled";
+
+ private PathMatchingFilter filter;
+
+ @Parameterized.Parameter(0)
+ public String pattern;
+
+ @Parameterized.Parameter(1)
+ public HttpServletRequest request;
+
+ @Parameterized.Parameter(2)
+ public boolean shouldMatch;
+
+ /**
+ * Tests the following assumptions:
+ *
+ * <pre>
+ * URL Must match pattern Must not match pattern
+ * /foo/ /foo/* /foo* || /foo
+ * /foo/bar /foo/* /foo* || /foo
+ * /foo /foo /foo/*
+ * </pre>
+ */
+ @Parameterized.Parameters
+ public static Object[][] generateParameters() {
+
+ return Stream.of(
+ new Object[]{ "/foo/*", createRequest("/foo/"), true },
+ new Object[]{ "/foo*", createRequest("/foo/"), true },
+ new Object[]{ "/foo", createRequest("/foo/"), true },
+
+ new Object[]{ "/foo/*", createRequest("/foo/bar"), true },
+ new Object[]{ "/foo*", createRequest("/foo/bar"), false },
+ new Object[]{ "/foo", createRequest("/foo/bar"), false },
+
+ new Object[]{ "/foo", createRequest("/foo"), true },
+ new Object[]{ "/foo/*", createRequest("/foo"), false },
+ new Object[]{ "/foo/*", createRequest("/foo "), false },
+ new Object[]{ "/foo/*", createRequest("/foo /"), false },
+ new Object[]{ "/foo/*", createRequest("/foo%20"), false }, // already URL decoded, encoded would have been %2520
+ new Object[]{ "/foo/*", createRequest("/foo%20/"), false },
+ new Object[]{ "/foo/*", createRequest("/foo/%20/"), true },
+ new Object[]{ "/foo/*", createRequest("/foo/ /"), true }
+ )
+ .toArray(Object[][]::new);
+ }
+
+ public static HttpServletRequest createRequest(String requestUri) {
+ return createRequest(requestUri, "", requestUri);
+ }
+
+ public static HttpServletRequest createRequest(String requestUri, String servletPath, String pathInfo) {
+ HttpServletRequest request = createNiceMock(HttpServletRequest.class);
+ expect(request.getContextPath()).andReturn(CONTEXT_PATH).anyTimes();
+ expect(request.getRequestURI()).andReturn(requestUri).anyTimes();
+ expect(request.getServletPath()).andReturn(servletPath).anyTimes();
+ expect(request.getPathInfo()).andReturn(pathInfo).anyTimes();
+ replay(request);
+
+ return request;
+ }
+
+ @Before
+ public void setUp() {
+ filter = createTestInstance();
+ }
+
+ private PathMatchingFilter createTestInstance() {
+ final String NAME = "pathMatchingFilter";
+
+ PathMatchingFilter filter = new PathMatchingFilter() {
+ @Override
+ protected boolean isEnabled(ServletRequest request, ServletResponse response, String path, Object mappedValue) throws Exception {
+ return !path.equals(DISABLED_PATH);
+ }
+
+ @Override
+ protected boolean onPreHandle(ServletRequest request, ServletResponse response, Object mappedValue) throws Exception {
+ //simulate a subclass that handles the response itself (A 'false' return value indicates that the
+ //FilterChain should not continue to be executed)
+ //
+ //This method should only be called if the filter is enabled, so we know if the return value is
+ //false, then the filter was enabled. A true return value from 'onPreHandle' indicates this test
+ //filter was disabled or a path wasn't matched.
+ return false;
+ }
+ };
+ filter.setName(NAME);
+
+ return filter;
+ }
+
+ @Test
+ public void testBasicAssumptions() {
+ LOG.debug("Input pattern: [{}], input path: [{}].", this.pattern, this.request.getPathInfo());
+ boolean matchEnabled = filter.pathsMatch(this.pattern, this.request);
+ assertEquals("PathMatch can match URL end with multi Separator, ["+ this.pattern + "] - [" + this.request.getPathInfo() + "]", this.shouldMatch, matchEnabled);
+ verify(request);
+ }
+}
diff --git a/web/src/test/java/org/apache/shiro/web/filter/authc/BasicHttpFilterAuthenticationTest.java b/web/src/test/java/org/apache/shiro/web/filter/authc/BasicHttpFilterAuthenticationTest.java
index ef7fa26..0760775 100644
--- a/web/src/test/java/org/apache/shiro/web/filter/authc/BasicHttpFilterAuthenticationTest.java
+++ b/web/src/test/java/org/apache/shiro/web/filter/authc/BasicHttpFilterAuthenticationTest.java
@@ -18,23 +18,23 @@
*/
package org.apache.shiro.web.filter.authc;
-import static org.easymock.EasyMock.createMock;
-import static org.easymock.EasyMock.expect;
-import static org.easymock.EasyMock.replay;
-import static org.easymock.EasyMock.verify;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertNotNull;
-import static org.junit.Assert.assertTrue;
-
-import javax.servlet.http.HttpServletRequest;
-import javax.servlet.http.HttpServletResponse;
-
import org.apache.shiro.authc.AuthenticationToken;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.lang.codec.Base64;
import org.apache.shiro.test.SecurityManagerTestSupport;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+
+import javax.servlet.http.HttpServletRequest;
+import javax.servlet.http.HttpServletResponse;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
/**
@@ -45,193 +45,174 @@
BasicHttpAuthenticationFilter testFilter;
- @Before
+ @BeforeEach
public void setUp() {
}
@Test
public void createTokenNoAuthorizationHeader() throws Exception {
testFilter = new BasicHttpAuthenticationFilter();
- HttpServletRequest request = createMock(HttpServletRequest.class);
- expect(request.getHeader("Authorization")).andReturn(null);
- expect(request.getRemoteHost()).andReturn("localhost");
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ when(request.getHeader("Authorization")).then(args -> null);
+ when(request.getRemoteHost()).then(args -> "localhost");
- HttpServletResponse response = createMock(HttpServletResponse.class);
-
- replay(request);
- replay(response);
+ HttpServletResponse response = mock(HttpServletResponse.class);
AuthenticationToken token = testFilter.createToken(request, response);
assertNotNull(token);
- assertTrue("Token is not a username and password token.", token instanceof UsernamePasswordToken);
+ assertTrue(token instanceof UsernamePasswordToken, "Token is not a username and password token.");
assertEquals("", token.getPrincipal());
- verify(request);
- verify(response);
+ verify(request).getHeader("Authorization");
+ verify(request).getRemoteHost();
}
@Test
public void createTokenNoUsername() throws Exception {
testFilter = new BasicHttpAuthenticationFilter();
- HttpServletRequest request = createMock(HttpServletRequest.class);
- expect(request.getHeader("Authorization")).andReturn(createAuthorizationHeader("", ""));
- expect(request.getRemoteHost()).andReturn("localhost");
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ when(request.getHeader("Authorization")).then(args -> createAuthorizationHeader("", ""));
+ when(request.getRemoteHost()).then(args -> "localhost");
- HttpServletResponse response = createMock(HttpServletResponse.class);
+ HttpServletResponse response = mock(HttpServletResponse.class);
- replay(request);
- replay(response);
AuthenticationToken token = testFilter.createToken(request, response);
assertNotNull(token);
- assertTrue("Token is not a username and password token.", token instanceof UsernamePasswordToken);
+ assertTrue(token instanceof UsernamePasswordToken, "Token is not a username and password token.");
assertEquals("", token.getPrincipal());
-
- verify(request);
- verify(response);
+
+ verify(request).getHeader("Authorization");
+ verify(request).getRemoteHost();
}
@Test
public void createTokenNoPassword() throws Exception {
testFilter = new BasicHttpAuthenticationFilter();
- HttpServletRequest request = createMock(HttpServletRequest.class);
- expect(request.getHeader("Authorization")).andReturn(createAuthorizationHeader("pedro", ""));
- expect(request.getRemoteHost()).andReturn("localhost");
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ when(request.getHeader("Authorization")).then(args -> createAuthorizationHeader("pedro", ""));
+ when(request.getRemoteHost()).then(args -> "localhost");
- HttpServletResponse response = createMock(HttpServletResponse.class);
+ HttpServletResponse response = mock(HttpServletResponse.class);
- replay(request);
- replay(response);
AuthenticationToken token = testFilter.createToken(request, response);
assertNotNull(token);
- assertTrue("Token is not a username and password token.", token instanceof UsernamePasswordToken);
+ assertTrue(token instanceof UsernamePasswordToken, "Token is not a username and password token.");
UsernamePasswordToken upToken = (UsernamePasswordToken) token;
assertEquals("pedro", upToken.getUsername());
- assertEquals("Password is not empty.", 0, upToken.getPassword().length);
-
- verify(request);
- verify(response);
+ assertEquals(0, upToken.getPassword().length, "Password is not empty.");
+
+ verify(request).getHeader("Authorization");
+ verify(request).getRemoteHost();
}
@Test
public void createTokenColonInPassword() throws Exception {
testFilter = new BasicHttpAuthenticationFilter();
- HttpServletRequest request = createMock(HttpServletRequest.class);
- expect(request.getHeader("Authorization")).andReturn(createAuthorizationHeader("pedro", "pass:word"));
- expect(request.getRemoteHost()).andReturn("localhost");
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ when(request.getHeader("Authorization")).then(args -> createAuthorizationHeader("pedro", "pass:word"));
+ when(request.getRemoteHost()).then(args -> "localhost");
- HttpServletResponse response = createMock(HttpServletResponse.class);
+ HttpServletResponse response = mock(HttpServletResponse.class);
- replay(request);
- replay(response);
AuthenticationToken token = testFilter.createToken(request, response);
assertNotNull(token);
- assertTrue("Token is not a username and password token.", token instanceof UsernamePasswordToken);
+ assertTrue(token instanceof UsernamePasswordToken, "Token is not a username and password token.");
UsernamePasswordToken upToken = (UsernamePasswordToken) token;
assertEquals("pedro", upToken.getUsername());
assertEquals("pass:word", new String(upToken.getPassword()));
- verify(request);
- verify(response);
+ verify(request).getHeader("Authorization");
+ verify(request).getRemoteHost();
}
@Test
public void httpMethodDoesNotRequireAuthentication() throws Exception {
testFilter = new BasicHttpAuthenticationFilter();
- HttpServletRequest request = createMock(HttpServletRequest.class);
- expect(request.getMethod()).andReturn("GET");
- replay(request);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ when(request.getMethod()).then(args -> "GET");
- HttpServletResponse response = createMock(HttpServletResponse.class);
- replay(response);
+ HttpServletResponse response = mock(HttpServletResponse.class);
boolean accessAllowed = testFilter.isAccessAllowed(request, response, new String[] { "POST", "PUT", "DELETE" });
- assertTrue("Access not allowed for GET", accessAllowed);
+ assertTrue(accessAllowed, "Access not allowed for GET");
}
@Test
public void httpMethodRequiresAuthentication() throws Exception {
testFilter = new BasicHttpAuthenticationFilter();
- HttpServletRequest request = createMock(HttpServletRequest.class);
- expect(request.getHeader("Authorization")).andReturn(createAuthorizationHeader("pedro", ""));
- expect(request.getRemoteHost()).andReturn("localhost");
- expect(request.getMethod()).andReturn("POST");
- replay(request);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ when(request.getHeader("Authorization")).then(args -> createAuthorizationHeader("pedro", ""));
+ when(request.getRemoteHost()).then(args -> "localhost");
+ when(request.getMethod()).then(args -> "POST");
- HttpServletResponse response = createMock(HttpServletResponse.class);
- replay(response);
+ HttpServletResponse response = mock(HttpServletResponse.class);
boolean accessAllowed = testFilter.isAccessAllowed(request, response, new String[] { "POST", "PUT", "DELETE" });
- assertTrue("Access allowed for POST", !accessAllowed);
+ assertFalse(accessAllowed, "Access allowed for POST");
}
@Test
public void httpMethodsAreCaseInsensitive() throws Exception {
testFilter = new BasicHttpAuthenticationFilter();
- HttpServletRequest request = createMock(HttpServletRequest.class);
- expect(request.getMethod()).andReturn("GET");
- expect(request.getMethod()).andReturn("post");
- expect(request.getHeader("Authorization")).andReturn(createAuthorizationHeader("pedro", "")).anyTimes();
- expect(request.getRemoteHost()).andReturn("localhost").anyTimes();
- replay(request);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ when(request.getMethod()).then(args -> "GET");
+ when(request.getHeader("Authorization")).then(args -> createAuthorizationHeader("pedro", ""));
+ when(request.getRemoteHost()).then(args -> "localhost");
- HttpServletResponse response = createMock(HttpServletResponse.class);
- replay(response);
+ HttpServletResponse response = mock(HttpServletResponse.class);
boolean accessAllowed = testFilter.isAccessAllowed(request, response, new String[] { "POST", "put", "delete" });
- assertTrue("Access not allowed for GET", accessAllowed);
-
+ assertTrue(accessAllowed, "Access not allowed for GET");
+
+ when(request.getMethod()).then(args -> "post");
accessAllowed = testFilter.isAccessAllowed(request, response, new String[] { "post", "put", "delete" });
- assertTrue("Access allowed for POST", !accessAllowed);
+ assertFalse(accessAllowed, "Access allowed for POST");
}
@Test
public void allHttpMethodsRequireAuthenticationIfNoneConfigured() throws Exception {
testFilter = new BasicHttpAuthenticationFilter();
- HttpServletRequest request = createMock(HttpServletRequest.class);
- expect(request.getHeader("Authorization")).andReturn(createAuthorizationHeader("pedro", "")).anyTimes();
- expect(request.getRemoteHost()).andReturn("localhost").anyTimes();
- expect(request.getMethod()).andReturn("GET");
- expect(request.getMethod()).andReturn("POST");
- replay(request);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ when(request.getHeader("Authorization")).then(args -> createAuthorizationHeader("pedro", ""));
+ when(request.getRemoteHost()).then(args -> "localhost");
+ when(request.getMethod()).then(args -> "GET");
+ when(request.getMethod()).then(args -> "POST");
- HttpServletResponse response = createMock(HttpServletResponse.class);
- replay(response);
+ HttpServletResponse response = mock(HttpServletResponse.class);
boolean accessAllowed = testFilter.isAccessAllowed(request, response, new String[0]);
- assertTrue("Access allowed for GET", !accessAllowed);
+ assertFalse(accessAllowed, "Access allowed for GET");
accessAllowed = testFilter.isAccessAllowed(request, response, new String[0]);
- assertTrue("Access allowed for POST", !accessAllowed);
+ assertFalse(accessAllowed, "Access allowed for POST");
}
@Test
public void allHttpMethodsRequireAuthenticationIfNullConfig() throws Exception {
testFilter = new BasicHttpAuthenticationFilter();
- HttpServletRequest request = createMock(HttpServletRequest.class);
- expect(request.getHeader("Authorization")).andReturn(createAuthorizationHeader("pedro", "")).anyTimes();
- expect(request.getRemoteHost()).andReturn("localhost").anyTimes();
- expect(request.getMethod()).andReturn("GET");
- expect(request.getMethod()).andReturn("POST");
- replay(request);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ when(request.getHeader("Authorization")).then(args -> createAuthorizationHeader("pedro", ""));
+ when(request.getRemoteHost()).then(args -> "localhost");
+ when(request.getMethod()).then(args -> "GET");
+ when(request.getMethod()).then(args -> "POST");
- HttpServletResponse response = createMock(HttpServletResponse.class);
- replay(response);
+ HttpServletResponse response = mock(HttpServletResponse.class);
boolean accessAllowed = testFilter.isAccessAllowed(request, response, null);
- assertTrue("Access allowed for GET", !accessAllowed);
+ assertFalse(accessAllowed, "Access allowed for GET");
accessAllowed = testFilter.isAccessAllowed(request, response, null);
- assertTrue("Access allowed for POST", !accessAllowed);
+ assertFalse(accessAllowed, "Access allowed for POST");
}
/**
@@ -241,18 +222,16 @@
public void permissiveEnabledWithLoginTest() {
testFilter = new BasicHttpAuthenticationFilter();
- HttpServletRequest request = createMock(HttpServletRequest.class);
- expect(request.getHeader("Authorization")).andReturn(createAuthorizationHeader("pedro", "")).anyTimes();
- expect(request.getRemoteHost()).andReturn("localhost").anyTimes();
- expect(request.getMethod()).andReturn("GET");
- replay(request);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ when(request.getHeader("Authorization")).then(args -> createAuthorizationHeader("pedro", ""));
+ when(request.getRemoteHost()).then(args -> "localhost");
+ when(request.getMethod()).then(args -> "GET");
- HttpServletResponse response = createMock(HttpServletResponse.class);
- replay(response);
+ HttpServletResponse response = mock(HttpServletResponse.class);
String[] mappedValue = {"permissive"};
boolean accessAllowed = testFilter.isAccessAllowed(request, response, mappedValue);
- assertTrue("Access allowed for GET", !accessAllowed); // login attempt should always be false
+ assertFalse(accessAllowed, "Access allowed for GET"); // login attempt should always be false
}
/**
@@ -262,18 +241,16 @@
public void permissiveEnabledTest() {
testFilter = new BasicHttpAuthenticationFilter();
- HttpServletRequest request = createMock(HttpServletRequest.class);
- expect(request.getHeader("Authorization")).andReturn(null).anyTimes();
- expect(request.getRemoteHost()).andReturn("localhost").anyTimes();
- expect(request.getMethod()).andReturn("GET");
- replay(request);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ when(request.getHeader("Authorization")).then(args -> null);
+ when(request.getRemoteHost()).then(args -> "localhost");
+ when(request.getMethod()).then(args -> "GET");
- HttpServletResponse response = createMock(HttpServletResponse.class);
- replay(response);
+ HttpServletResponse response = mock(HttpServletResponse.class);
String[] mappedValue = {"permissive"};
boolean accessAllowed = testFilter.isAccessAllowed(request, response, mappedValue);
- assertTrue("Access should be allowed for GET", accessAllowed); // non-login attempt, return true
+ assertTrue(accessAllowed, "Access should be allowed for GET"); // non-login attempt, return true
}
/**
@@ -283,17 +260,15 @@
public void httpMethodRequiresAuthenticationWithPermissive() throws Exception {
testFilter = new BasicHttpAuthenticationFilter();
- HttpServletRequest request = createMock(HttpServletRequest.class);
- expect(request.getHeader("Authorization")).andReturn(createAuthorizationHeader("pedro", ""));
- expect(request.getRemoteHost()).andReturn("localhost");
- expect(request.getMethod()).andReturn("POST");
- replay(request);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ when(request.getHeader("Authorization")).then(args -> createAuthorizationHeader("pedro", ""));
+ when(request.getRemoteHost()).then(args -> "localhost");
+ when(request.getMethod()).then(args -> "POST");
- HttpServletResponse response = createMock(HttpServletResponse.class);
- replay(response);
+ HttpServletResponse response = mock(HttpServletResponse.class);
boolean accessAllowed = testFilter.isAccessAllowed(request, response, new String[] {"permissive", "POST", "PUT", "DELETE" });
- assertTrue("Access allowed for POST", !accessAllowed);
+ assertFalse(accessAllowed, "Access allowed for POST");
}
private String createAuthorizationHeader(String username, String password) {
diff --git a/web/src/test/java/org/apache/shiro/web/filter/authz/AuthorizationFilterTest.java b/web/src/test/java/org/apache/shiro/web/filter/authz/AuthorizationFilterTest.java
index dba7cb5..c02f1d2 100644
--- a/web/src/test/java/org/apache/shiro/web/filter/authz/AuthorizationFilterTest.java
+++ b/web/src/test/java/org/apache/shiro/web/filter/authz/AuthorizationFilterTest.java
@@ -21,7 +21,9 @@
import org.apache.shiro.SecurityUtils;
import org.apache.shiro.authc.UsernamePasswordToken;
import org.apache.shiro.test.SecurityManagerTestSupport;
-import org.junit.Test;
+import org.junit.jupiter.api.Disabled;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
@@ -29,14 +31,19 @@
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
-import static org.easymock.EasyMock.*;
+import static org.mockito.Mockito.atLeastOnce;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
/**
* Test cases for the {@link AuthorizationFilter} class.
*/
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
public class AuthorizationFilterTest extends SecurityManagerTestSupport {
@Test
+ @Disabled
public void testUserOnAccessDeniedWithResponseError() throws IOException {
// Tests when a user (known identity) is denied access and no unauthorizedUrl has been configured.
// This should trigger an HTTP response error code.
@@ -46,22 +53,21 @@
AuthorizationFilter filter = new AuthorizationFilter() {
@Override
- protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue)
- throws Exception {
+ protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
return false; //for this test case
}
};
- HttpServletRequest request = createNiceMock(HttpServletRequest.class);
- HttpServletResponse response = createNiceMock(HttpServletResponse.class);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ HttpServletResponse response = mock(HttpServletResponse.class);
- response.sendError(HttpServletResponse.SC_UNAUTHORIZED);
- replay(response);
+ // response.sendError(HttpServletResponse.SC_UNAUTHORIZED);
filter.onAccessDenied(request, response);
- verify(response);
+ verify(response).sendError(HttpServletResponse.SC_UNAUTHORIZED);
}
@Test
+ @Disabled
public void testUserOnAccessDeniedWithRedirect() throws IOException {
// Tests when a user (known identity) is denied access and an unauthorizedUrl *has* been configured.
// This should trigger an HTTP redirect
@@ -73,27 +79,22 @@
AuthorizationFilter filter = new AuthorizationFilter() {
@Override
- protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue)
- throws Exception {
+ protected boolean isAccessAllowed(ServletRequest request, ServletResponse response, Object mappedValue) {
return false; //for this test case
}
};
filter.setUnauthorizedUrl(unauthorizedUrl);
- HttpServletRequest request = createNiceMock(HttpServletRequest.class);
- HttpServletResponse response = createNiceMock(HttpServletResponse.class);
-
- expect(request.getContextPath()).andReturn("/").anyTimes();
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ HttpServletResponse response = mock(HttpServletResponse.class);
String encoded = "/" + unauthorizedUrl;
- expect(response.encodeRedirectURL(unauthorizedUrl)).andReturn(encoded);
+ when(response.encodeRedirectURL(unauthorizedUrl)).thenReturn(encoded);
response.sendRedirect(encoded);
- replay(request);
- replay(response);
filter.onAccessDenied(request, response);
- verify(request);
- verify(response);
+ verify(response, atLeastOnce()).sendRedirect(encoded);
+ verify(response).encodeRedirectURL(unauthorizedUrl);
}
}
diff --git a/web/src/test/java/org/apache/shiro/web/filter/mgt/PathMatchingFilterChainResolverTest.java b/web/src/test/java/org/apache/shiro/web/filter/mgt/PathMatchingFilterChainResolverTest.java
index f13e8ea..db4de61 100644
--- a/web/src/test/java/org/apache/shiro/web/filter/mgt/PathMatchingFilterChainResolverTest.java
+++ b/web/src/test/java/org/apache/shiro/web/filter/mgt/PathMatchingFilterChainResolverTest.java
@@ -30,8 +30,15 @@
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
-import static org.easymock.EasyMock.*;
-import static org.junit.Assert.*;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.notNullValue;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
/**
* Tests for {@link org.apache.shiro.web.filter.mgt.PathMatchingFilterChainResolver}.
@@ -58,14 +65,12 @@
@Test
public void testNewInstanceWithFilterConfig() {
FilterConfig mock = createNiceMockFilterConfig();
- replay(mock);
resolver = new PathMatchingFilterChainResolver(mock);
assertNotNull(resolver.getPathMatcher());
assertTrue(resolver.getPathMatcher() instanceof AntPathMatcher);
assertNotNull(resolver.getFilterChainManager());
assertTrue(resolver.getFilterChainManager() instanceof DefaultFilterChainManager);
assertEquals(((DefaultFilterChainManager) resolver.getFilterChainManager()).getFilterConfig(), mock);
- verify(mock);
}
@Test
@@ -80,82 +85,78 @@
@Test
public void testGetChainsWithoutChains() {
- ServletRequest request = createNiceMock(HttpServletRequest.class);
- ServletResponse response = createNiceMock(HttpServletResponse.class);
- FilterChain chain = createNiceMock(FilterChain.class);
+ ServletRequest request = mock(HttpServletRequest.class);
+ ServletResponse response = mock(HttpServletResponse.class);
+ FilterChain chain = mock(FilterChain.class);
FilterChain resolved = resolver.getChain(request, response, chain);
assertNull(resolved);
}
@Test
public void testGetChainsWithMatch() {
- HttpServletRequest request = createNiceMock(HttpServletRequest.class);
- HttpServletResponse response = createNiceMock(HttpServletResponse.class);
- FilterChain chain = createNiceMock(FilterChain.class);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ HttpServletResponse response = mock(HttpServletResponse.class);
+ FilterChain chain = mock(FilterChain.class);
//ensure at least one chain is defined:
resolver.getFilterChainManager().addToChain("/index.html", "authcBasic");
- expect(request.getServletPath()).andReturn("");
- expect(request.getPathInfo()).andReturn("/index.html");
- replay(request);
+ when(request.getServletPath()).thenReturn("");
+ when(request.getPathInfo()).thenReturn("/index.html");
FilterChain resolved = resolver.getChain(request, response, chain);
assertNotNull(resolved);
- verify(request);
+ verify(request).getServletPath();
}
@Test
public void testPathTraversalWithDot() {
- HttpServletRequest request = createNiceMock(HttpServletRequest.class);
- HttpServletResponse response = createNiceMock(HttpServletResponse.class);
- FilterChain chain = createNiceMock(FilterChain.class);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ HttpServletResponse response = mock(HttpServletResponse.class);
+ FilterChain chain = mock(FilterChain.class);
//ensure at least one chain is defined:
resolver.getFilterChainManager().addToChain("/index.html", "authcBasic");
- expect(request.getServletPath()).andReturn("/");
- expect(request.getPathInfo()).andReturn("./index.html");
- replay(request);
+ when(request.getServletPath()).thenReturn("/");
+ when(request.getPathInfo()).thenReturn("./index.html");
FilterChain resolved = resolver.getChain(request, response, chain);
assertNotNull(resolved);
- verify(request);
+ verify(request).getServletPath();
}
@Test
public void testPathTraversalWithDotDot() {
- HttpServletRequest request = createNiceMock(HttpServletRequest.class);
- HttpServletResponse response = createNiceMock(HttpServletResponse.class);
- FilterChain chain = createNiceMock(FilterChain.class);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ HttpServletResponse response = mock(HttpServletResponse.class);
+ FilterChain chain = mock(FilterChain.class);
//ensure at least one chain is defined:
resolver.getFilterChainManager().addToChain("/index.html", "authcBasic");
- expect(request.getServletPath()).andReturn("/public/");
- expect(request.getPathInfo()).andReturn("../index.html");
- replay(request);
+ when(request.getServletPath()).thenReturn("/public/");
+ when(request.getPathInfo()).thenReturn("../index.html");
FilterChain resolved = resolver.getChain(request, response, chain);
assertNotNull(resolved);
- verify(request);
+ verify(request).getServletPath();
}
@Test
public void testGetChainsWithoutMatch() {
- HttpServletRequest request = createNiceMock(HttpServletRequest.class);
- HttpServletResponse response = createNiceMock(HttpServletResponse.class);
- FilterChain chain = createNiceMock(FilterChain.class);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ HttpServletResponse response = mock(HttpServletResponse.class);
+ FilterChain chain = mock(FilterChain.class);
//ensure at least one chain is defined:
resolver.getFilterChainManager().addToChain("/index.html", "authcBasic");
- expect(request.getServletPath()).andReturn("/");
- expect(request.getPathInfo()).andReturn(null);
- replay(request);
+ when(request.getServletPath()).thenReturn("/");
+ when(request.getPathInfo()).thenReturn(null);
FilterChain resolved = resolver.getChain(request, response, chain);
assertNull(resolved);
- verify(request);
+ verify(request).getServletPath();
}
/**
@@ -163,20 +164,19 @@
*/
@Test
public void testGetChain() {
- HttpServletRequest request = createNiceMock(HttpServletRequest.class);
- HttpServletResponse response = createNiceMock(HttpServletResponse.class);
- FilterChain chain = createNiceMock(FilterChain.class);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ HttpServletResponse response = mock(HttpServletResponse.class);
+ FilterChain chain = mock(FilterChain.class);
//ensure at least one chain is defined:
resolver.getFilterChainManager().addToChain("/resource/book", "authcBasic");
- expect(request.getServletPath()).andReturn("");
- expect(request.getPathInfo()).andReturn("/resource/book");
- replay(request);
+ when(request.getServletPath()).thenReturn("");
+ when(request.getPathInfo()).thenReturn("/resource/book");
FilterChain resolved = resolver.getChain(request, response, chain);
assertNotNull(resolved);
- verify(request);
+ verify(request).getServletPath();
}
/**
@@ -184,20 +184,19 @@
*/
@Test
public void testGetChainEqualUrlSeparator() {
- HttpServletRequest request = createNiceMock(HttpServletRequest.class);
- HttpServletResponse response = createNiceMock(HttpServletResponse.class);
- FilterChain chain = createNiceMock(FilterChain.class);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ HttpServletResponse response = mock(HttpServletResponse.class);
+ FilterChain chain = mock(FilterChain.class);
//ensure at least one chain is defined:
resolver.getFilterChainManager().addToChain("/", "authcBasic");
- expect(request.getServletPath()).andReturn("/");
- expect(request.getPathInfo()).andReturn(null);
- replay(request);
+ when(request.getServletPath()).thenReturn("/");
+ when(request.getPathInfo()).thenReturn(null);
FilterChain resolved = resolver.getChain(request, response, chain);
assertNotNull(resolved);
- verify(request);
+ verify(request).getServletPath();
}
/**
@@ -205,20 +204,19 @@
*/
@Test
public void testGetChainEndWithUrlSeparator() {
- HttpServletRequest request = createNiceMock(HttpServletRequest.class);
- HttpServletResponse response = createNiceMock(HttpServletResponse.class);
- FilterChain chain = createNiceMock(FilterChain.class);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ HttpServletResponse response = mock(HttpServletResponse.class);
+ FilterChain chain = mock(FilterChain.class);
//ensure at least one chain is defined:
resolver.getFilterChainManager().addToChain("/resource/book", "authcBasic");
- expect(request.getServletPath()).andReturn("");
- expect(request.getPathInfo()).andReturn("/resource/book");
- replay(request);
+ when(request.getServletPath()).thenReturn("");
+ when(request.getPathInfo()).thenReturn("/resource/book");
FilterChain resolved = resolver.getChain(request, response, chain);
assertNotNull(resolved);
- verify(request);
+ verify(request).getServletPath();
}
/**
@@ -226,19 +224,35 @@
*/
@Test
public void testGetChainEndWithMultiUrlSeparator() {
- HttpServletRequest request = createNiceMock(HttpServletRequest.class);
- HttpServletResponse response = createNiceMock(HttpServletResponse.class);
- FilterChain chain = createNiceMock(FilterChain.class);
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ HttpServletResponse response = mock(HttpServletResponse.class);
+ FilterChain chain = mock(FilterChain.class);
//ensure at least one chain is defined:
resolver.getFilterChainManager().addToChain("/resource/book", "authcBasic");
- expect(request.getServletPath()).andReturn("");
- expect(request.getPathInfo()).andReturn("/resource/book//");
- replay(request);
+ when(request.getServletPath()).thenReturn("");
+ when(request.getPathInfo()).thenReturn("/resource/book//");
FilterChain resolved = resolver.getChain(request, response, chain);
assertNotNull(resolved);
- verify(request);
+ verify(request).getServletPath();
+ }
+
+ @Test
+ public void testMultipleChainsPathEndsWithSlash() {
+ HttpServletRequest request = mock(HttpServletRequest.class);
+ HttpServletResponse response = mock(HttpServletResponse.class);
+ FilterChain chain = mock(FilterChain.class);
+
+ //Define the filter chain
+ resolver.getFilterChainManager().addToChain("/login", "authc");
+ resolver.getFilterChainManager().addToChain("/resource/*", "authcBasic");
+
+ when(request.getServletPath()).thenReturn("");
+ when(request.getPathInfo()).thenReturn("/resource/");
+
+ FilterChain resolved = resolver.getChain(request, response, chain);
+ assertThat(resolved, notNullValue());
}
}
diff --git a/web/src/test/java/org/apache/shiro/web/mgt/DefaultWebSecurityManagerTest.java b/web/src/test/java/org/apache/shiro/web/mgt/DefaultWebSecurityManagerTest.java
index 21c440b..443b030 100644
--- a/web/src/test/java/org/apache/shiro/web/mgt/DefaultWebSecurityManagerTest.java
+++ b/web/src/test/java/org/apache/shiro/web/mgt/DefaultWebSecurityManagerTest.java
@@ -42,8 +42,16 @@
import javax.servlet.http.HttpServletResponse;
import java.io.Serializable;
-import static org.easymock.EasyMock.*;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
/**
* @since 0.9
@@ -62,6 +70,7 @@
sm.setRealm(new IniRealm(ini));
}
+ @Override
@After
public void tearDown() {
sm.destroy();
@@ -75,17 +84,15 @@
@Test
public void checkSessionManagerDeterminesContainerSessionMode() {
sm.setSessionMode(DefaultWebSecurityManager.NATIVE_SESSION_MODE);
- WebSessionManager sessionManager = createMock(WebSessionManager.class);
+ WebSessionManager sessionManager = mock(WebSessionManager.class);
- expect(sessionManager.isServletContainerSessions()).andReturn(true).anyTimes();
-
- replay(sessionManager);
+ when(sessionManager.isServletContainerSessions()).thenReturn(true);
sm.setSessionManager(sessionManager);
assertTrue("The set SessionManager is not being used to determine isHttpSessionMode.", sm.isHttpSessionMode());
- verify(sessionManager);
+ verify(sessionManager).isServletContainerSessions();
}
@Test
@@ -103,13 +110,12 @@
@Test
public void testLogin() {
- HttpServletRequest mockRequest = createNiceMock(HttpServletRequest.class);
- HttpServletResponse mockResponse = createNiceMock(HttpServletResponse.class);
+ HttpServletRequest mockRequest = mock(HttpServletRequest.class);
+ HttpServletResponse mockResponse = mock(HttpServletResponse.class);
- expect(mockRequest.getCookies()).andReturn(null);
- expect(mockRequest.getContextPath()).andReturn("/");
+ when(mockRequest.getCookies()).thenReturn(null);
+ when(mockRequest.getContextPath()).thenReturn("/");
- replay(mockRequest);
Subject subject = newSubject(mockRequest, mockResponse);
@@ -119,7 +125,7 @@
assertTrue(subject.isAuthenticated());
assertNotNull(subject.getPrincipal());
- assertTrue(subject.getPrincipal().equals("lonestarr"));
+ assertEquals("lonestarr", subject.getPrincipal());
}
@Test
@@ -128,13 +134,11 @@
long globalTimeout = 100;
((AbstractSessionManager) sm.getSessionManager()).setGlobalSessionTimeout(globalTimeout);
- HttpServletRequest mockRequest = createNiceMock(HttpServletRequest.class);
- HttpServletResponse mockResponse = createNiceMock(HttpServletResponse.class);
+ HttpServletRequest mockRequest = mock(HttpServletRequest.class);
+ HttpServletResponse mockResponse = mock(HttpServletResponse.class);
- expect(mockRequest.getCookies()).andReturn(null);
- expect(mockRequest.getContextPath()).andReturn("/");
-
- replay(mockRequest);
+ when(mockRequest.getCookies()).thenReturn(null);
+ when(mockRequest.getContextPath()).thenReturn("/");
Subject subject = newSubject(mockRequest, mockResponse);
@@ -154,22 +158,16 @@
public void testGetSubjectByRequestResponsePair() {
shiroSessionModeInit();
- HttpServletRequest mockRequest = createNiceMock(HttpServletRequest.class);
- HttpServletResponse mockResponse = createNiceMock(HttpServletResponse.class);
+ HttpServletRequest mockRequest = mock(HttpServletRequest.class);
+ HttpServletResponse mockResponse = mock(HttpServletResponse.class);
- expect(mockRequest.getCookies()).andReturn(null);
-
- replay(mockRequest);
- replay(mockResponse);
+ when(mockRequest.getCookies()).thenReturn(null);
Subject subject = newSubject(mockRequest, mockResponse);
- verify(mockRequest);
- verify(mockResponse);
-
assertNotNull(subject);
assertTrue(subject.getPrincipals() == null || subject.getPrincipals().isEmpty());
- assertTrue(subject.getSession(false) == null);
+ assertNull(subject.getSession(false));
assertFalse(subject.isAuthenticated());
}
@@ -178,11 +176,8 @@
shiroSessionModeInit();
- HttpServletRequest mockRequest = createNiceMock(HttpServletRequest.class);
- HttpServletResponse mockResponse = createNiceMock(HttpServletResponse.class);
-
- replay(mockRequest);
- replay(mockResponse);
+ HttpServletRequest mockRequest = mock(HttpServletRequest.class);
+ HttpServletResponse mockResponse = mock(HttpServletResponse.class);
Subject subject = newSubject(mockRequest, mockResponse);
@@ -191,27 +186,18 @@
assertNotNull(sessionId);
- verify(mockRequest);
- verify(mockResponse);
-
- mockRequest = createNiceMock(HttpServletRequest.class);
- mockResponse = createNiceMock(HttpServletResponse.class);
+ mockRequest = mock(HttpServletRequest.class);
+ mockResponse = mock(HttpServletResponse.class);
//now simulate the cookie going with the request and the Subject should be acquired based on that:
Cookie[] cookies = new Cookie[]{new Cookie(ShiroHttpSession.DEFAULT_SESSION_ID_NAME, sessionId.toString())};
- expect(mockRequest.getCookies()).andReturn(cookies).anyTimes();
- expect(mockRequest.getParameter(isA(String.class))).andReturn(null).anyTimes();
-
- replay(mockRequest);
- replay(mockResponse);
+ when(mockRequest.getCookies()).thenReturn(cookies);
+ when(mockRequest.getParameter(any(String.class))).thenReturn(null);
subject = newSubject(mockRequest, mockResponse);
session = subject.getSession(false);
assertNotNull(session);
assertEquals(sessionId, session.getId());
-
- verify(mockRequest);
- verify(mockResponse);
}
/**
diff --git a/web/src/test/java/org/apache/shiro/web/servlet/ShiroHttpServletRequestTest.java b/web/src/test/java/org/apache/shiro/web/servlet/ShiroHttpServletRequestTest.java
index 85da229..b74911a 100644
--- a/web/src/test/java/org/apache/shiro/web/servlet/ShiroHttpServletRequestTest.java
+++ b/web/src/test/java/org/apache/shiro/web/servlet/ShiroHttpServletRequestTest.java
@@ -18,54 +18,64 @@
*/
package org.apache.shiro.web.servlet;
-import static org.easymock.EasyMock.*;
-
-import javax.servlet.ServletContext;
-import javax.servlet.http.HttpServletRequest;
-
import org.apache.shiro.session.Session;
import org.apache.shiro.subject.Subject;
import org.apache.shiro.util.ThreadContext;
-import org.junit.Before;
-import org.junit.Test;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
-import junit.framework.TestCase;
+import javax.servlet.ServletContext;
+import javax.servlet.http.HttpServletRequest;
+import java.util.concurrent.atomic.AtomicInteger;
-public class ShiroHttpServletRequestTest extends TestCase {
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.mockito.Mockito.atLeast;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
- private ShiroHttpServletRequest request;
-
- private HttpServletRequest mockRequest;
- private ServletContext mockContext;
- private Subject mockSubject;
-
- @Before
+public class ShiroHttpServletRequestTest {
+
+ private ShiroHttpServletRequest request;
+
+ private HttpServletRequest mockRequest = mock(HttpServletRequest.class);
+ private ServletContext mockContext = mock(ServletContext.class);
+ private Subject mockSubject = mock(Subject.class);
+
+ @BeforeEach
public void setUp() throws Exception {
- this.mockRequest = createMock(HttpServletRequest.class);
- this.mockContext = createMock(ServletContext.class);
- this.mockSubject = createMock(Subject.class);
-
- ThreadContext.bind(this.mockSubject);
- this.request = new ShiroHttpServletRequest(mockRequest, mockContext, false);
+ ThreadContext.bind(this.mockSubject);
+ this.request = new ShiroHttpServletRequest(mockRequest, mockContext, false);
}
/**
* Test asserting <a href="https://issues.apache.org/jira/browse/SHIRO-637">SHIRO-637<a/>.
*/
@Test
- public void testRegetSession() throws Exception {
- Session session1 = createMock(Session.class);
- Session session2 = createMock(Session.class);
-
+ public void testRegetSession() {
+ Session session1 = mock(Session.class);
+ Session session2 = mock(Session.class);
+ AtomicInteger counter = new AtomicInteger();
+ AtomicInteger counterFalse = new AtomicInteger();
+
mockSubject.logout();
- expect(mockSubject.getSession(true))
- .andReturn(session1).times(1)
- .andReturn(session2).times(1);
- expect(mockSubject.getSession(false))
- .andReturn(session1).times(2)
- .andReturn(null).times(3);
- replay(mockSubject);
-
+ when(mockSubject.getSession(true)).then(args -> {
+ if (counter.getAndIncrement() == 1) {
+ return session1;
+ }
+
+ return session2;
+ });
+ when(mockSubject.getSession(false)).then(args -> {
+ if (counterFalse.getAndIncrement() < 2) {
+ return session1;
+ }
+
+ return null;
+ });
+
assertNotNull(request.getSession(true));
assertNotNull(request.getSession(false));
@@ -73,6 +83,7 @@
assertNull(request.getSession(false));
assertNotNull(request.getSession(true));
- verify(mockSubject);
+ verify(mockSubject, times(2)).getSession(true);
+ verify(mockSubject, atLeast(3)).getSession(false);
}
}
