| /* |
| * 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.struts2.convention; |
| |
| import com.opensymphony.xwork2.*; |
| import com.opensymphony.xwork2.config.Configuration; |
| import com.opensymphony.xwork2.config.entities.*; |
| import com.opensymphony.xwork2.config.impl.DefaultConfiguration; |
| import com.opensymphony.xwork2.factory.DefaultInterceptorFactory; |
| import com.opensymphony.xwork2.factory.DefaultResultFactory; |
| import com.opensymphony.xwork2.inject.Container; |
| import com.opensymphony.xwork2.inject.Scope.Strategy; |
| import com.opensymphony.xwork2.ognl.OgnlReflectionProvider; |
| import com.opensymphony.xwork2.util.TextParseUtil; |
| import com.opensymphony.xwork2.util.fs.DefaultFileManager; |
| import com.opensymphony.xwork2.util.fs.DefaultFileManagerFactory; |
| import com.opensymphony.xwork2.util.reflection.ReflectionException; |
| import junit.framework.TestCase; |
| |
| import org.apache.commons.lang3.StringUtils; |
| import org.apache.struts2.convention.actions.DefaultResultPathAction; |
| import org.apache.struts2.convention.actions.NoAnnotationAction; |
| import org.apache.struts2.convention.actions.Skip; |
| import org.apache.struts2.convention.actions.action.*; |
| import org.apache.struts2.convention.actions.allowedmethods.ClassLevelAllowedMethodsAction; |
| import org.apache.struts2.convention.actions.allowedmethods.PackageLevelAllowedMethodsAction; |
| import org.apache.struts2.convention.actions.allowedmethods.sub.PackageLevelAllowedMethodsChildAction; |
| import org.apache.struts2.convention.actions.chain.ChainedAction; |
| import org.apache.struts2.convention.actions.defaultinterceptor.SingleActionNameAction2; |
| import org.apache.struts2.convention.actions.exception.ExceptionsActionLevelAction; |
| import org.apache.struts2.convention.actions.exception.ExceptionsMethodLevelAction; |
| import org.apache.struts2.convention.actions.exclude.ExcludeAction; |
| import org.apache.struts2.convention.actions.interceptor.ActionLevelInterceptor2Action; |
| import org.apache.struts2.convention.actions.interceptor.ActionLevelInterceptor3Action; |
| import org.apache.struts2.convention.actions.interceptor.ActionLevelInterceptorAction; |
| import org.apache.struts2.convention.actions.interceptor.InterceptorsAction; |
| import org.apache.struts2.convention.actions.namespace.ActionLevelNamespaceAction; |
| import org.apache.struts2.convention.actions.namespace.ClassLevelNamespaceAction; |
| import org.apache.struts2.convention.actions.namespace.PackageLevelNamespaceAction; |
| import org.apache.struts2.convention.actions.namespace2.DefaultNamespaceAction; |
| import org.apache.struts2.convention.actions.namespace3.ActionLevelNamespacesAction; |
| import org.apache.struts2.convention.actions.namespace4.ActionAndPackageLevelNamespacesAction; |
| import org.apache.struts2.convention.actions.params.ActionParamsMethodLevelAction; |
| import org.apache.struts2.convention.actions.parentpackage.ClassLevelParentPackageAction; |
| import org.apache.struts2.convention.actions.parentpackage.PackageLevelParentPackageAction; |
| import org.apache.struts2.convention.actions.parentpackage.sub.ClassLevelParentPackageChildAction; |
| import org.apache.struts2.convention.actions.parentpackage.sub.PackageLevelParentPackageChildAction; |
| import org.apache.struts2.convention.actions.result.*; |
| import org.apache.struts2.convention.actions.resultpath.ClassLevelResultPathAction; |
| import org.apache.struts2.convention.actions.resultpath.PackageLevelResultPathAction; |
| import org.apache.struts2.convention.actions.skip.Index; |
| import org.apache.struts2.convention.actions.transactions.TransNameAction; |
| import org.apache.struts2.convention.annotation.Action; |
| import org.apache.struts2.convention.annotation.Actions; |
| import org.apache.struts2.convention.dontfind.DontFindMeAction; |
| import org.apache.struts2.result.ServletDispatcherResult; |
| import org.easymock.EasyMock; |
| |
| import javax.servlet.ServletContext; |
| import java.net.MalformedURLException; |
| import java.util.*; |
| |
| import static org.apache.struts2.convention.ReflectionTools.getAnnotation; |
| import static org.easymock.EasyMock.*; |
| |
| /** |
| * <p> |
| * This is a test for the package based name builder. |
| * </p> |
| */ |
| public class PackageBasedActionConfigBuilderTest extends TestCase { |
| |
| @Override |
| public void setUp() throws Exception { |
| super.setUp(); |
| ActionContext context = new ActionContext(new HashMap<String, Object>()); |
| context.setContainer(new DummyContainer()); |
| ActionContext.setContext(context); |
| } |
| |
| public void testActionPackages() throws MalformedURLException { |
| run("org.apache.struts2.convention.actions", null, null); |
| } |
| |
| public void testPackageLocators() throws MalformedURLException { |
| run(null, "actions,dontfind", null); |
| } |
| |
| public void testExcludedPackages() throws MalformedURLException { |
| run(null, "actions", "dontfind"); |
| } |
| |
| public void testJustExcludedPackages() throws MalformedURLException { |
| run("org.apache.struts2.convention.actions", null, "org.apache.struts2.convention.actions.exclude"); |
| } |
| |
| public void testSmiInheritanceEnabled() throws MalformedURLException { |
| run("org.apache.struts2.convention.actions", null, null, "true"); |
| } |
| |
| public void testSmiInheritanceDisabled() throws MalformedURLException { |
| run("org.apache.struts2.convention.actions", null, null, "false"); |
| } |
| |
| private void run(String actionPackages, String packageLocators, String excludePackages) throws MalformedURLException { |
| run(actionPackages, packageLocators, excludePackages, ""); |
| } |
| private void run(String actionPackages, String packageLocators, String excludePackages, String enableSmiInheritance) throws MalformedURLException { |
| //setup interceptors |
| List<InterceptorConfig> defaultInterceptors = new ArrayList<>(); |
| defaultInterceptors.add(makeInterceptorConfig("interceptor-1")); |
| defaultInterceptors.add(makeInterceptorConfig("interceptor-2")); |
| defaultInterceptors.add(makeInterceptorConfig("interceptor-3")); |
| |
| //setup interceptor stacks |
| List<InterceptorStackConfig> defaultInterceptorStacks = new ArrayList<>(); |
| InterceptorMapping interceptor1 = new InterceptorMapping("interceptor-1", new TestInterceptor()); |
| InterceptorMapping interceptor2 = new InterceptorMapping("interceptor-2", new TestInterceptor()); |
| defaultInterceptorStacks.add(makeInterceptorStackConfig("stack-1", interceptor1, interceptor2)); |
| |
| //setup strict MethodInvocation |
| boolean strictMethodInvocation = true; |
| boolean isSmiInheritanceEnabled = false; |
| // Sets the SMI value to false so we can test that the created package configs adopt the SMI value of their parent. |
| // If enableSmiInheritance is set to false it is expected that the generated package configs have their SMI value set to true (the default) |
| // even when the SMI of their parent is set to false. |
| if (StringUtils.equals(enableSmiInheritance, "true")) { |
| strictMethodInvocation = false; |
| isSmiInheritanceEnabled = true; |
| } else if (StringUtils.equals(enableSmiInheritance, "false")) { |
| strictMethodInvocation = false; |
| } |
| |
| //setup results |
| ResultTypeConfig[] defaultResults = new ResultTypeConfig[]{new ResultTypeConfig.Builder("dispatcher", |
| ServletDispatcherResult.class.getName()).defaultResultParam("location").build(), |
| new ResultTypeConfig.Builder("chain", |
| ActionChainResult.class.getName()).defaultResultParam("actionName").build()}; |
| |
| Set<String> globalAllowedMethods = TextParseUtil.commaDelimitedStringToSet("execute,browse,cancel,input"); |
| |
| PackageConfig strutsDefault = makePackageConfig("struts-default", null, null, "dispatcher", |
| defaultResults, defaultInterceptors, defaultInterceptorStacks, globalAllowedMethods, strictMethodInvocation); |
| PackageConfig packageLevelParentPkg = makePackageConfig("package-level", null, null, null); |
| PackageConfig classLevelParentPkg = makePackageConfig("class-level", null, null, null); |
| |
| PackageConfig rootPkg = makePackageConfig("org.apache.struts2.convention.actions#struts-default#", |
| "", strutsDefault, null); |
| PackageConfig paramsPkg = makePackageConfig("org.apache.struts2.convention.actions.params#struts-default#/params", |
| "/params", strutsDefault, null); |
| PackageConfig defaultInterceptorPkg = makePackageConfig("org.apache.struts2.convention.actions.defaultinterceptor#struts-default#/defaultinterceptor", |
| "/defaultinterceptor", strutsDefault, null); |
| PackageConfig exceptionPkg = makePackageConfig("org.apache.struts2.convention.actions.exception#struts-default#/exception", |
| "/exception", strutsDefault, null); |
| PackageConfig actionPkg = makePackageConfig("org.apache.struts2.convention.actions.action#struts-default#/action", |
| "/action", strutsDefault, null); |
| PackageConfig idxPkg = makePackageConfig("org.apache.struts2.convention.actions.idx#struts-default#/idx", |
| "/idx", strutsDefault, null); |
| PackageConfig idx2Pkg = makePackageConfig("org.apache.struts2.convention.actions.idx.idx2#struts-default#/idx/idx2", |
| "/idx/idx2", strutsDefault, null); |
| PackageConfig interceptorRefsPkg = makePackageConfig("org.apache.struts2.convention.actions.interceptor#struts-default#/interceptor", |
| "/interceptor", strutsDefault, null); |
| PackageConfig packageLevelPkg = makePackageConfig("org.apache.struts2.convention.actions.parentpackage#package-level#/parentpackage", |
| "/parentpackage", packageLevelParentPkg, null); |
| PackageConfig packageLevelSubPkg = makePackageConfig("org.apache.struts2.convention.actions.parentpackage.sub#package-level#/parentpackage/sub", |
| "/parentpackage/sub", packageLevelParentPkg, null); |
| |
| // Unexpected method call build(class org.apache.struts2.convention.actions.allowedmethods.PackageLevelAllowedMethodsAction, null, "package-level-allowed-methods", PackageConfig: [org.apache.struts2.convention.actions.allowedmethods#struts-default#/allowedmethods] for namespace [/allowedmethods] with parents [[PackageConfig: [struts-default] for namespace [] with parents [[]]]]): |
| PackageConfig packageLevelAllowedMethodsPkg = makePackageConfig("org.apache.struts2.convention.actions.allowedmethods#struts-default#/allowedmethods", |
| "/allowedmethods", strutsDefault, null); |
| PackageConfig packageLevelAllowedMethodsSubPkg = makePackageConfig("org.apache.struts2.convention.actions.allowedmethods.sub#struts-default#/allowedmethods/sub", |
| "/allowedmethods/sub", strutsDefault, null); |
| |
| PackageConfig classLevelAllowedMethodsPkg = makePackageConfig("org.apache.struts2.convention.actions.allowedmethods#struts-default#/allowedmethods", |
| "/allowedmethods", strutsDefault, null); |
| |
| PackageConfig differentPkg = makePackageConfig("org.apache.struts2.convention.actions.parentpackage#class-level#/parentpackage", |
| "/parentpackage", classLevelParentPkg, null); |
| PackageConfig differentSubPkg = makePackageConfig("org.apache.struts2.convention.actions.parentpackage.sub#class-level#/parentpackage/sub", |
| "/parentpackage/sub", classLevelParentPkg, null); |
| PackageConfig pkgLevelNamespacePkg = makePackageConfig("org.apache.struts2.convention.actions.namespace#struts-default#/package-level", |
| "/package-level", strutsDefault, null); |
| PackageConfig classLevelNamespacePkg = makePackageConfig("org.apache.struts2.convention.actions.namespace#struts-default#/class-level", |
| "/class-level", strutsDefault, null); |
| PackageConfig actionLevelNamespacePkg = makePackageConfig("org.apache.struts2.convention.actions.namespace#struts-default#/action-level", |
| "/action-level", strutsDefault, null); |
| PackageConfig defaultNamespacePkg = makePackageConfig("org.apache.struts2.convention.actions.namespace2#struts-default#/namespace2", |
| "/namespace2", strutsDefault, null); |
| PackageConfig namespaces1Pkg = makePackageConfig("org.apache.struts2.convention.actions.namespace3#struts-default#/namespaces1", |
| "/namespaces1", strutsDefault, null); |
| PackageConfig namespaces2Pkg = makePackageConfig("org.apache.struts2.convention.actions.namespace3#struts-default#/namespaces2", |
| "/namespaces2", strutsDefault, null); |
| PackageConfig namespaces3Pkg = makePackageConfig("org.apache.struts2.convention.actions.namespace4#struts-default#/namespaces3", |
| "/namespaces3", strutsDefault, null); |
| PackageConfig namespaces4Pkg = makePackageConfig("org.apache.struts2.convention.actions.namespace4#struts-default#/namespaces4", |
| "/namespaces4", strutsDefault, null); |
| PackageConfig resultPkg = makePackageConfig("org.apache.struts2.convention.actions.result#struts-default#/result", |
| "/result", strutsDefault, null); |
| PackageConfig globalResultPkg = makePackageConfig("org.apache.struts2.convention.actions.result#class-level#/result", |
| "/result", classLevelParentPkg, null); |
| PackageConfig resultPathPkg = makePackageConfig("org.apache.struts2.convention.actions.resultpath#struts-default#/resultpath", |
| "/resultpath", strutsDefault, null); |
| PackageConfig skipPkg = makePackageConfig("org.apache.struts2.convention.actions.skip#struts-default#/skip", |
| "/skip", strutsDefault, null); |
| PackageConfig chainPkg = makePackageConfig("org.apache.struts2.convention.actions.chain#struts-default#/chain", |
| "/chain", strutsDefault, null); |
| PackageConfig transPkg = makePackageConfig("org.apache.struts2.convention.actions.transactions#struts-default#/transactions", |
| "/transactions", strutsDefault, null); |
| PackageConfig excludePkg = makePackageConfig("org.apache.struts2.convention.actions.exclude#struts-default#/exclude", |
| "/exclude", strutsDefault, null); |
| |
| ResultMapBuilder resultMapBuilder = createStrictMock(ResultMapBuilder.class); |
| checkOrder(resultMapBuilder, false); |
| Map<String, ResultConfig> results = new HashMap<>(); |
| |
| /* org.apache.struts2.convention.actions.action */ |
| expect(resultMapBuilder.build(ActionNameAction.class, getAnnotation(ActionNameAction.class, "run1", Action.class), "action1", actionPkg)).andReturn(results); |
| expect(resultMapBuilder.build(ClassNameAction.class, getAnnotation(ClassNameAction.class, "run1", Action.class), "action3", actionPkg)).andReturn(results); |
| expect(resultMapBuilder.build(ActionNameAction.class, getAnnotation(ActionNameAction.class, "run2", Action.class), "action2", actionPkg)).andReturn(results); |
| expect(resultMapBuilder.build(ActionNamesAction.class, getAnnotation(ActionNamesAction.class, "run", Actions.class).value()[0], "actions1", actionPkg)).andReturn(results); |
| expect(resultMapBuilder.build(ActionNamesAction.class, getAnnotation(ActionNamesAction.class, "run", Actions.class).value()[1], "actions2", actionPkg)).andReturn(results); |
| expect(resultMapBuilder.build(SingleActionNameAction.class, getAnnotation(SingleActionNameAction.class, "run", Action.class), "action", actionPkg)).andReturn(results); |
| expect(resultMapBuilder.build(TestAction.class, null, "test", actionPkg)).andReturn(results); |
| expect(resultMapBuilder.build(TestExtends.class, null, "test-extends", actionPkg)).andReturn(results); |
| |
| Actions classLevelActions = ClassLevelAnnotationsAction.class.getAnnotation(Actions.class); |
| expect(resultMapBuilder.build(ClassLevelAnnotationsAction.class, classLevelActions.value()[0], "class1", actionPkg)).andReturn(results); |
| expect(resultMapBuilder.build(ClassLevelAnnotationsAction.class, classLevelActions.value()[1], "class2", actionPkg)).andReturn(results); |
| |
| Actions classLevelActionsDefaultMethod = ClassLevelAnnotationsDefaultMethodAction.class.getAnnotation(Actions.class); |
| expect(resultMapBuilder.build(ClassLevelAnnotationsDefaultMethodAction.class, classLevelActionsDefaultMethod.value()[0], "class3", actionPkg)).andReturn(results); |
| expect(resultMapBuilder.build(ClassLevelAnnotationsDefaultMethodAction.class, classLevelActionsDefaultMethod.value()[1], "class4", actionPkg)).andReturn(results); |
| |
| expect(resultMapBuilder.build(ClassLevelAnnotationAction.class, ClassLevelAnnotationAction.class.getAnnotation(Action.class), "class5", actionPkg)).andReturn(results); |
| expect(resultMapBuilder.build(ClassLevelAnnotationDefaultMethodAction.class, ClassLevelAnnotationDefaultMethodAction.class.getAnnotation(Action.class), "class6", actionPkg)).andReturn(results); |
| |
| /* org.apache.struts2.convention.actions.idx */ |
| /* org.apache.struts2.convention.actions.idx.idx2 */ |
| expect(resultMapBuilder.build(org.apache.struts2.convention.actions.idx.Index.class, null, "index", idxPkg)).andReturn(results); |
| expect(resultMapBuilder.build(org.apache.struts2.convention.actions.idx.idx2.Index.class, null, "index", idx2Pkg)).andReturn(results); |
| |
| /* org.apache.struts2.convention.actions.params */ |
| expect(resultMapBuilder.build(ActionParamsMethodLevelAction.class, getAnnotation(ActionParamsMethodLevelAction.class, "run1", Action.class), "actionParam1", paramsPkg)).andReturn(results); |
| |
| /* org.apache.struts2.convention.actions.defaultinterceptor */ |
| expect(resultMapBuilder.build(SingleActionNameAction2.class, getAnnotation(SingleActionNameAction2.class, "execute", Action.class), "action345", defaultInterceptorPkg)).andReturn(results); |
| |
| /* org.apache.struts2.convention.actions.exception */ |
| expect(resultMapBuilder.build(ExceptionsMethodLevelAction.class, getAnnotation(ExceptionsMethodLevelAction.class, "run1", Action.class), "exception1", exceptionPkg)).andReturn(results); |
| expect(resultMapBuilder.build(ExceptionsActionLevelAction.class, getAnnotation(ExceptionsActionLevelAction.class, "execute", Action.class), "exceptions-action-level", exceptionPkg)).andReturn(results); |
| |
| /* org.apache.struts2.convention.actions.interceptor */ |
| expect(resultMapBuilder.build(InterceptorsAction.class, getAnnotation(InterceptorsAction.class, "run1", Action.class), "action100", interceptorRefsPkg)).andReturn(results); |
| expect(resultMapBuilder.build(InterceptorsAction.class, getAnnotation(InterceptorsAction.class, "run2", Action.class), "action200", interceptorRefsPkg)).andReturn(results); |
| expect(resultMapBuilder.build(InterceptorsAction.class, getAnnotation(InterceptorsAction.class, "run3", Action.class), "action300", interceptorRefsPkg)).andReturn(results); |
| expect(resultMapBuilder.build(InterceptorsAction.class, getAnnotation(InterceptorsAction.class, "run4", Action.class), "action400", interceptorRefsPkg)).andReturn(results); |
| |
| expect(resultMapBuilder.build(ActionLevelInterceptorAction.class, getAnnotation(ActionLevelInterceptorAction.class, "run1", Action.class), "action500", interceptorRefsPkg)).andReturn(results); |
| expect(resultMapBuilder.build(ActionLevelInterceptorAction.class, getAnnotation(ActionLevelInterceptorAction.class, "run2", Action.class), "action600", interceptorRefsPkg)).andReturn(results); |
| expect(resultMapBuilder.build(ActionLevelInterceptorAction.class, getAnnotation(ActionLevelInterceptorAction.class, "run3", Action.class), "action700", interceptorRefsPkg)).andReturn(results); |
| |
| expect(resultMapBuilder.build(ActionLevelInterceptor2Action.class, getAnnotation(ActionLevelInterceptor2Action.class, "run1", Action.class), "action800", interceptorRefsPkg)).andReturn(results); |
| expect(resultMapBuilder.build(ActionLevelInterceptor3Action.class, getAnnotation(ActionLevelInterceptor3Action.class, "run1", Action.class), "action900", interceptorRefsPkg)).andReturn(results); |
| |
| /* org.apache.struts2.convention.actions.namespace */ |
| expect(resultMapBuilder.build(ActionLevelNamespaceAction.class, getAnnotation(ActionLevelNamespaceAction.class, "execute", Action.class), "action", actionLevelNamespacePkg)).andReturn(results); |
| expect(resultMapBuilder.build(ClassLevelNamespaceAction.class, null, "class-level-namespace", classLevelNamespacePkg)).andReturn(results); |
| expect(resultMapBuilder.build(PackageLevelNamespaceAction.class, null, "package-level-namespace", pkgLevelNamespacePkg)).andReturn(results); |
| |
| /* org.apache.struts2.convention.actions.namespace2 */ |
| expect(resultMapBuilder.build(DefaultNamespaceAction.class, null, "default-namespace", defaultNamespacePkg)).andReturn(results); |
| |
| /* org.apache.struts2.convention.actions.namespace3 */ |
| expect(resultMapBuilder.build(ActionLevelNamespacesAction.class, null, "action-level-namespaces", namespaces1Pkg)).andReturn(results); |
| expect(resultMapBuilder.build(ActionLevelNamespacesAction.class, null, "action-level-namespaces", namespaces2Pkg)).andReturn(results); |
| |
| /* org.apache.struts2.convention.actions.namespace4 */ |
| expect(resultMapBuilder.build(ActionAndPackageLevelNamespacesAction.class, null, "action-and-package-level-namespaces", namespaces3Pkg)).andReturn(results); |
| expect(resultMapBuilder.build(ActionAndPackageLevelNamespacesAction.class, null, "action-and-package-level-namespaces", namespaces4Pkg)).andReturn(results); |
| |
| /* org.apache.struts2.convention.actions.parentpackage */ |
| expect(resultMapBuilder.build(PackageLevelParentPackageAction.class, null, "package-level-parent-package", packageLevelPkg)).andReturn(results); |
| expect(resultMapBuilder.build(PackageLevelParentPackageChildAction.class, null, "package-level-parent-package-child", packageLevelSubPkg)).andReturn(results); |
| expect(resultMapBuilder.build(ClassLevelParentPackageAction.class, null, "class-level-parent-package", differentPkg)).andReturn(results); |
| expect(resultMapBuilder.build(ClassLevelParentPackageChildAction.class, null, "class-level-parent-package-child", differentSubPkg)).andReturn(results); |
| |
| /* org.apache.struts2.convention.actions.allowedmethods */ |
| expect(resultMapBuilder.build(ClassLevelAllowedMethodsAction.class, null, "class-level-allowed-methods", classLevelAllowedMethodsPkg)).andReturn(results); |
| expect(resultMapBuilder.build(PackageLevelAllowedMethodsAction.class, null, "package-level-allowed-methods", packageLevelAllowedMethodsPkg)).andReturn(results); |
| expect(resultMapBuilder.build(PackageLevelAllowedMethodsChildAction.class, null, "package-level-allowed-methods-child", packageLevelAllowedMethodsSubPkg)).andReturn(results); |
| |
| /* org.apache.struts2.convention.actions.result */ |
| expect(resultMapBuilder.build(ClassLevelResultAction.class, null, "class-level-result", resultPkg)).andReturn(results); |
| expect(resultMapBuilder.build(ClassLevelResultsAction.class, null, "class-level-results", resultPkg)).andReturn(results); |
| expect(resultMapBuilder.build(ActionLevelResultAction.class, getAnnotation(ActionLevelResultAction.class, "execute", Action.class), "action-level-result", resultPkg)).andReturn(results); |
| expect(resultMapBuilder.build(ActionLevelResultsAction.class, getAnnotation(ActionLevelResultsAction.class, "execute", Action.class), "action-level-results", resultPkg)).andReturn(results); |
| expect(resultMapBuilder.build(InheritedResultExtends.class, null, "inherited-result-extends", resultPkg)).andReturn(results); |
| expect(resultMapBuilder.build(OverrideResultAction.class, getAnnotation(OverrideResultAction.class, "execute", Action.class), "override-result", resultPkg)).andReturn(results); |
| expect(resultMapBuilder.build(GlobalResultAction.class, null, "global-result", globalResultPkg)).andReturn(results); |
| expect(resultMapBuilder.build(GlobalResultOverrideAction.class, null, "global-result-override", globalResultPkg)).andReturn(results); |
| expect(resultMapBuilder.build(ActionLevelResultsNamesAction.class, getAnnotation(ActionLevelResultsNamesAction.class, "execute", Action.class), "action-level-results-names", resultPkg)).andReturn(results); |
| expect(resultMapBuilder.build(ActionLevelResultsNamesAction.class, getAnnotation(ActionLevelResultsNamesAction.class, "noname", Action.class), "action-level-results-names", resultPkg)).andReturn(results); |
| |
| /* org.apache.struts2.convention.actions.resultpath */ |
| expect(resultMapBuilder.build(ClassLevelResultPathAction.class, null, "class-level-result-path", resultPathPkg)).andReturn(results); |
| expect(resultMapBuilder.build(PackageLevelResultPathAction.class, null, "package-level-result-path", resultPathPkg)).andReturn(results); |
| |
| /* org.apache.struts2.convention.actions */ |
| expect(resultMapBuilder.build(NoAnnotationAction.class, null, "no-annotation", rootPkg)).andReturn(results); |
| expect(resultMapBuilder.build(DefaultResultPathAction.class, null, "default-result-path", rootPkg)).andReturn(results); |
| expect(resultMapBuilder.build(Skip.class, null, "skip", rootPkg)).andReturn(results); |
| |
| /* org.apache.struts2.convention.actions.skip */ |
| expect(resultMapBuilder.build(Index.class, null, "index", skipPkg)).andReturn(results); |
| |
| /* org.apache.struts2.convention.actions.chain */ |
| expect(resultMapBuilder.build(ChainedAction.class, getAnnotation(ChainedAction.class, "foo", Action.class), "foo", chainPkg)).andReturn(results); |
| expect(resultMapBuilder.build(ChainedAction.class, getAnnotation(ChainedAction.class, "bar", Action.class), "foo-bar", chainPkg)).andReturn(results); |
| |
| /* org.apache.struts2.convention.actions.transactions */ |
| expect(resultMapBuilder.build(TransNameAction.class, getAnnotation(TransNameAction.class, "trans1", Action.class), "trans1", transPkg)).andReturn(results); |
| expect(resultMapBuilder.build(TransNameAction.class, getAnnotation(TransNameAction.class, "trans2", Action.class), "trans2", transPkg)).andReturn(results); |
| |
| /* org.apache.struts2.convention.actions.exclude */ |
| // this is only expected when excludePackages was specified with org.apache.struts2.convention.actions.exclude package |
| if (excludePackages == null || !excludePackages.contains("org.apache.struts2.convention.actions.exclude")) { |
| expect(resultMapBuilder.build(ExcludeAction.class, getAnnotation(ExcludeAction.class, "run1", Action.class), "exclude1", excludePkg)).andReturn(results); |
| } |
| |
| EasyMock.replay(resultMapBuilder); |
| |
| final DummyContainer mockContainer = new DummyContainer(); |
| |
| Configuration configuration = new DefaultConfiguration() { |
| |
| @Override |
| public Container getContainer() { |
| return mockContainer; |
| } |
| |
| }; |
| |
| configuration.addPackageConfig("struts-default", strutsDefault); |
| configuration.addPackageConfig("package-level", packageLevelParentPkg); |
| configuration.addPackageConfig("class-level", classLevelParentPkg); |
| |
| ActionNameBuilder actionNameBuilder = new SEOActionNameBuilder("true", "-"); |
| ObjectFactory of = new ObjectFactory(); |
| of.setContainer(mockContainer); |
| DefaultInterceptorMapBuilder interceptorBuilder = new DefaultInterceptorMapBuilder(); |
| interceptorBuilder.setConfiguration(configuration); |
| |
| //set beans on mock container |
| mockContainer.setActionNameBuilder(actionNameBuilder); |
| mockContainer.setInterceptorMapBuilder(interceptorBuilder); |
| mockContainer.setResultMapBuilder(resultMapBuilder); |
| mockContainer.setConventionsService(new ConventionsServiceImpl("")); |
| |
| PackageBasedActionConfigBuilder builder = new PackageBasedActionConfigBuilder(configuration, mockContainer , of, "false", "struts-default", enableSmiInheritance); |
| builder.setFileProtocols("jar"); |
| if (actionPackages != null) { |
| builder.setActionPackages(actionPackages); |
| } |
| if (packageLocators != null) { |
| builder.setPackageLocators(packageLocators); |
| } |
| if (excludePackages != null) { |
| builder.setExcludePackages(excludePackages); |
| } |
| DefaultFileManagerFactory fileManagerFactory = new DefaultFileManagerFactory(); |
| fileManagerFactory.setContainer(ActionContext.getContext().getContainer()); |
| fileManagerFactory.setFileManager(new DefaultFileManager()); |
| builder.setFileManagerFactory(fileManagerFactory); |
| builder.setPackageLocatorsBase("org.apache.struts2.convention.actions"); |
| builder.buildActionConfigs(); |
| verify(resultMapBuilder); |
| |
| /* org.apache.struts2.convention.actions.action */ |
| PackageConfig pkgConfig = configuration.getPackageConfig("org.apache.struts2.convention.actions.action#struts-default#/action"); |
| assertNotNull(pkgConfig); |
| checkSmiValue(pkgConfig, strutsDefault, isSmiInheritanceEnabled); |
| assertEquals(14, pkgConfig.getActionConfigs().size()); |
| verifyActionConfig(pkgConfig, "action1", ActionNameAction.class, "run1", pkgConfig.getName()); |
| verifyActionConfig(pkgConfig, "action2", ActionNameAction.class, "run2", pkgConfig.getName()); |
| verifyMissingActionConfig(pkgConfig, "foo", DontFindMeAction.class, "foo", pkgConfig.getName()); |
| verifyActionConfig(pkgConfig, "action3", "someClassName", "run1", pkgConfig.getName()); |
| verifyActionConfig(pkgConfig, "actions1", ActionNamesAction.class, "run", pkgConfig.getName()); |
| verifyActionConfig(pkgConfig, "actions2", ActionNamesAction.class, "run", pkgConfig.getName()); |
| verifyActionConfig(pkgConfig, "action", SingleActionNameAction.class, "run", pkgConfig.getName()); |
| verifyActionConfig(pkgConfig, "test", TestAction.class, "execute", pkgConfig.getName()); |
| verifyActionConfig(pkgConfig, "test-extends", TestExtends.class, "execute", pkgConfig.getName()); |
| |
| verifyActionConfig(pkgConfig, "class1", ClassLevelAnnotationsAction.class, null, pkgConfig.getName()); |
| verifyActionConfig(pkgConfig, "class2", ClassLevelAnnotationsAction.class, null, pkgConfig.getName()); |
| verifyActionConfig(pkgConfig, "class3", ClassLevelAnnotationsDefaultMethodAction.class, "execute", pkgConfig.getName()); |
| verifyActionConfig(pkgConfig, "class4", ClassLevelAnnotationsDefaultMethodAction.class, "execute", pkgConfig.getName()); |
| verifyActionConfig(pkgConfig, "class5", ClassLevelAnnotationAction.class, null, pkgConfig.getName()); |
| verifyActionConfig(pkgConfig, "class6", ClassLevelAnnotationDefaultMethodAction.class, "execute", pkgConfig.getName()); |
| verifyActionConfig(pkgConfig, "class6", ClassLevelAnnotationDefaultMethodAction.class, "execute", pkgConfig.getName()); |
| |
| /* org.apache.struts2.convention.actions.namespace3 */ |
| //action on namespace1 (action level) |
| pkgConfig = configuration.getPackageConfig("org.apache.struts2.convention.actions.namespace3#struts-default#/namespaces1"); |
| assertNotNull(pkgConfig); |
| checkSmiValue(pkgConfig, strutsDefault, isSmiInheritanceEnabled); |
| assertEquals(1, pkgConfig.getActionConfigs().size()); |
| verifyActionConfig(pkgConfig, "action-level-namespaces", ActionLevelNamespacesAction.class, "execute", pkgConfig.getName()); |
| |
| //action on namespace2 (action level) |
| pkgConfig = configuration.getPackageConfig("org.apache.struts2.convention.actions.namespace3#struts-default#/namespaces2"); |
| assertNotNull(pkgConfig); |
| checkSmiValue(pkgConfig, strutsDefault, isSmiInheritanceEnabled); |
| assertEquals(1, pkgConfig.getActionConfigs().size()); |
| verifyActionConfig(pkgConfig, "action-level-namespaces", ActionLevelNamespacesAction.class, "execute", pkgConfig.getName()); |
| |
| /* org.apache.struts2.convention.actions.namespace4 */ |
| //action on namespace3 (action level) |
| pkgConfig = configuration.getPackageConfig("org.apache.struts2.convention.actions.namespace4#struts-default#/namespaces3"); |
| assertNotNull(pkgConfig); |
| checkSmiValue(pkgConfig, strutsDefault, isSmiInheritanceEnabled); |
| assertEquals(1, pkgConfig.getActionConfigs().size()); |
| verifyActionConfig(pkgConfig, "action-and-package-level-namespaces", ActionAndPackageLevelNamespacesAction.class, "execute", pkgConfig.getName()); |
| |
| //action on namespace4 (package level) |
| pkgConfig = configuration.getPackageConfig("org.apache.struts2.convention.actions.namespace4#struts-default#/namespaces4"); |
| assertNotNull(pkgConfig); |
| checkSmiValue(pkgConfig, strutsDefault, isSmiInheritanceEnabled); |
| assertEquals(1, pkgConfig.getActionConfigs().size()); |
| verifyActionConfig(pkgConfig, "action-and-package-level-namespaces", ActionAndPackageLevelNamespacesAction.class, "execute", pkgConfig.getName()); |
| |
| |
| |
| /* org.apache.struts2.convention.actions.params */ |
| pkgConfig = configuration.getPackageConfig("org.apache.struts2.convention.actions.params#struts-default#/params"); |
| assertNotNull(pkgConfig); |
| checkSmiValue(pkgConfig, strutsDefault, isSmiInheritanceEnabled); |
| assertEquals(1, pkgConfig.getActionConfigs().size()); |
| ActionConfig ac = pkgConfig.getAllActionConfigs().get("actionParam1"); |
| assertNotNull(ac); |
| Map<String, String> params = ac.getParams(); |
| assertNotNull(params); |
| assertEquals(2, params.size()); |
| assertEquals("val1", params.get("param1")); |
| assertEquals("val2", params.get("param2")); |
| |
| /* org.apache.struts2.convention.actions.params */ |
| pkgConfig = configuration.getPackageConfig("org.apache.struts2.convention.actions.exception#struts-default#/exception"); |
| assertNotNull(pkgConfig); |
| checkSmiValue(pkgConfig, strutsDefault, isSmiInheritanceEnabled); |
| assertEquals(2, pkgConfig.getActionConfigs().size()); |
| |
| ac = pkgConfig.getAllActionConfigs().get("exception1"); |
| assertNotNull(ac); |
| List<ExceptionMappingConfig> exceptions = ac.getExceptionMappings(); |
| assertNotNull(exceptions); |
| assertEquals(2, exceptions.size()); |
| ExceptionMappingConfig exception = exceptions.get(0); |
| assertEquals("NPE1", exception.getExceptionClassName()); |
| assertEquals("success", exception.getResult()); |
| exception = exceptions.get(1); |
| assertEquals("NPE2", exception.getExceptionClassName()); |
| assertEquals("success", exception.getResult()); |
| params = exception.getParams(); |
| assertNotNull(params); |
| assertEquals(1, params.size()); |
| assertEquals("val1", params.get("param1")); |
| |
| ac = pkgConfig.getAllActionConfigs().get("exceptions-action-level"); |
| assertNotNull(ac); |
| exceptions = ac.getExceptionMappings(); |
| assertNotNull(exceptions); |
| assertEquals(2, exceptions.size()); |
| exception = exceptions.get(0); |
| assertEquals("NPE1", exception.getExceptionClassName()); |
| assertEquals("success", exception.getResult()); |
| exception = exceptions.get(1); |
| assertEquals("NPE2", exception.getExceptionClassName()); |
| assertEquals("success", exception.getResult()); |
| params = exception.getParams(); |
| assertNotNull(params); |
| assertEquals(1, params.size()); |
| assertEquals("val1", params.get("param1")); |
| |
| /* org.apache.struts2.convention.actions.idx */ |
| pkgConfig = configuration.getPackageConfig("org.apache.struts2.convention.actions.idx#struts-default#/idx"); |
| assertNotNull(pkgConfig); |
| checkSmiValue(pkgConfig, strutsDefault, isSmiInheritanceEnabled); |
| assertEquals(3, pkgConfig.getActionConfigs().size()); |
| verifyActionConfig(pkgConfig, "", org.apache.struts2.convention.actions.idx.Index.class, "execute", pkgConfig.getName()); |
| verifyActionConfig(pkgConfig, "index", org.apache.struts2.convention.actions.idx.Index.class, "execute", pkgConfig.getName()); |
| verifyActionConfig(pkgConfig, "idx2", org.apache.struts2.convention.actions.idx.idx2.Index.class, "execute", |
| "org.apache.struts2.convention.actions.idx.idx2#struts-default#/idx/idx2"); |
| |
| /* org.apache.struts2.convention.actions.defaultinterceptor */ |
| pkgConfig = configuration.getPackageConfig("org.apache.struts2.convention.actions.defaultinterceptor#struts-default#/defaultinterceptor"); |
| assertNotNull(pkgConfig); |
| checkSmiValue(pkgConfig, strutsDefault, isSmiInheritanceEnabled); |
| assertEquals("validationWorkflowStack", pkgConfig.getDefaultInterceptorRef()); |
| |
| /* org.apache.struts2.convention.actions.idx.idx2 */ |
| pkgConfig = configuration.getPackageConfig("org.apache.struts2.convention.actions.idx.idx2#struts-default#/idx/idx2"); |
| assertNotNull(pkgConfig); |
| checkSmiValue(pkgConfig, strutsDefault, isSmiInheritanceEnabled); |
| assertEquals(2, pkgConfig.getActionConfigs().size()); |
| verifyActionConfig(pkgConfig, "", org.apache.struts2.convention.actions.idx.idx2.Index.class, "execute", pkgConfig.getName()); |
| verifyActionConfig(pkgConfig, "index", org.apache.struts2.convention.actions.idx.idx2.Index.class, "execute", pkgConfig.getName()); |
| |
| /* org.apache.struts2.convention.actions.namespace action level */ |
| pkgConfig = configuration.getPackageConfig("org.apache.struts2.convention.actions.namespace#struts-default#/action-level"); |
| assertNotNull(pkgConfig); |
| checkSmiValue(pkgConfig, strutsDefault, isSmiInheritanceEnabled); |
| assertEquals(1, pkgConfig.getActionConfigs().size()); |
| verifyActionConfig(pkgConfig, "action", ActionLevelNamespaceAction.class, "execute", pkgConfig.getName()); |
| |
| /* org.apache.struts2.convention.actions.namespace class level */ |
| pkgConfig = configuration.getPackageConfig("org.apache.struts2.convention.actions.namespace#struts-default#/class-level"); |
| assertNotNull(pkgConfig); |
| checkSmiValue(pkgConfig, strutsDefault, isSmiInheritanceEnabled); |
| assertEquals(1, pkgConfig.getActionConfigs().size()); |
| verifyActionConfig(pkgConfig, "class-level-namespace", ClassLevelNamespaceAction.class, "execute", pkgConfig.getName()); |
| |
| /* org.apache.struts2.convention.actions.namespace package level */ |
| pkgConfig = configuration.getPackageConfig("org.apache.struts2.convention.actions.namespace#struts-default#/package-level"); |
| assertNotNull(pkgConfig); |
| checkSmiValue(pkgConfig, strutsDefault, isSmiInheritanceEnabled); |
| assertEquals(1, pkgConfig.getActionConfigs().size()); |
| verifyActionConfig(pkgConfig, "package-level-namespace", PackageLevelNamespaceAction.class, "execute", pkgConfig.getName()); |
| |
| /* org.apache.struts2.convention.actions.namespace2 */ |
| pkgConfig = configuration.getPackageConfig("org.apache.struts2.convention.actions.namespace2#struts-default#/namespace2"); |
| assertNotNull(pkgConfig); |
| checkSmiValue(pkgConfig, strutsDefault, isSmiInheritanceEnabled); |
| assertEquals(1, pkgConfig.getActionConfigs().size()); |
| verifyActionConfig(pkgConfig, "default-namespace", DefaultNamespaceAction.class, "execute", pkgConfig.getName()); |
| |
| /* org.apache.struts2.convention.actions.parentpackage class level */ |
| pkgConfig = configuration.getPackageConfig("org.apache.struts2.convention.actions.parentpackage#class-level#/parentpackage"); |
| assertNotNull(pkgConfig); |
| assertEquals(1, pkgConfig.getActionConfigs().size()); |
| verifyActionConfig(pkgConfig, "class-level-parent-package", ClassLevelParentPackageAction.class, "execute", pkgConfig.getName()); |
| |
| /* org.apache.struts2.convention.actions.parentpackage.sub class level */ |
| pkgConfig = configuration.getPackageConfig("org.apache.struts2.convention.actions.parentpackage.sub#class-level#/parentpackage/sub"); |
| assertNotNull(pkgConfig); |
| assertEquals(1, pkgConfig.getActionConfigs().size()); |
| verifyActionConfig(pkgConfig, "class-level-parent-package-child", ClassLevelParentPackageChildAction.class, "execute", pkgConfig.getName()); |
| assertEquals("class-level", pkgConfig.getParents().get(0).getName()); |
| |
| /* org.apache.struts2.convention.actions.parentpackage package level */ |
| pkgConfig = configuration.getPackageConfig("org.apache.struts2.convention.actions.parentpackage#package-level#/parentpackage"); |
| assertNotNull(pkgConfig); |
| assertEquals(1, pkgConfig.getActionConfigs().size()); |
| verifyActionConfig(pkgConfig, "package-level-parent-package", PackageLevelParentPackageAction.class, "execute", pkgConfig.getName()); |
| |
| /* org.apache.struts2.convention.actions.parentpackage.sub package level */ |
| pkgConfig = configuration.getPackageConfig("org.apache.struts2.convention.actions.parentpackage.sub#package-level#/parentpackage/sub"); |
| assertNotNull(pkgConfig); |
| assertEquals(1, pkgConfig.getActionConfigs().size()); |
| verifyActionConfig(pkgConfig, "package-level-parent-package-child", PackageLevelParentPackageChildAction.class, "execute", pkgConfig.getName()); |
| assertEquals("package-level", pkgConfig.getParents().get(0).getName()); |
| |
| /* org.apache.struts2.convention.actions.allowedmethods class level */ |
| pkgConfig = configuration.getPackageConfig("org.apache.struts2.convention.actions.allowedmethods#struts-default#/allowedmethods"); |
| assertNotNull(pkgConfig); |
| checkSmiValue(pkgConfig, strutsDefault, isSmiInheritanceEnabled); |
| assertEquals(2, pkgConfig.getActionConfigs().size()); |
| verifyActionConfig(pkgConfig, "class-level-allowed-methods", ClassLevelAllowedMethodsAction.class, "execute", pkgConfig.getName()); |
| assertEquals("struts-default", pkgConfig.getParents().get(0).getName()); |
| |
| ActionConfig actionConfig = pkgConfig.getActionConfigs().get("class-level-allowed-methods"); |
| assertTrue(actionConfig.getAllowedMethods().contains("execute")); |
| int allowedMethodsSize = actionConfig.getAllowedMethods().size(); |
| if (!pkgConfig.isStrictMethodInvocation()) { |
| // With strict method invocation disabled the allowed methods are "execute" and the wildcard "*" |
| assertEquals(2, allowedMethodsSize); |
| } else { |
| assertEquals(7, allowedMethodsSize); |
| assertTrue(actionConfig.getAllowedMethods().contains("end")); |
| assertTrue(actionConfig.getAllowedMethods().contains("input")); |
| assertTrue(actionConfig.getAllowedMethods().contains("cancel")); |
| assertTrue(actionConfig.getAllowedMethods().contains("start")); |
| assertTrue(actionConfig.getAllowedMethods().contains("home")); |
| assertTrue(actionConfig.getAllowedMethods().contains("browse")); |
| } |
| |
| /* org.apache.struts2.convention.actions.allowedmethods.sub package level */ |
| pkgConfig = configuration.getPackageConfig("org.apache.struts2.convention.actions.allowedmethods.sub#struts-default#/allowedmethods/sub"); |
| assertNotNull(pkgConfig); |
| checkSmiValue(pkgConfig, strutsDefault, isSmiInheritanceEnabled); |
| assertEquals(1, pkgConfig.getActionConfigs().size()); |
| verifyActionConfig(pkgConfig, "package-level-allowed-methods-child", PackageLevelAllowedMethodsChildAction.class, "execute", pkgConfig.getName()); |
| assertEquals("struts-default", pkgConfig.getParents().get(0).getName()); |
| |
| actionConfig = pkgConfig.getActionConfigs().get("package-level-allowed-methods-child"); |
| assertTrue(actionConfig.getAllowedMethods().contains("execute")); |
| allowedMethodsSize = actionConfig.getAllowedMethods().size(); |
| if (!pkgConfig.isStrictMethodInvocation()) { |
| // With strict method invocation disabled the allowed methods are execute and the wildcard * |
| assertEquals(2, allowedMethodsSize); |
| } else { |
| assertEquals(6, allowedMethodsSize); |
| assertTrue(actionConfig.getAllowedMethods().contains("home")); |
| assertTrue(actionConfig.getAllowedMethods().contains("start")); |
| assertTrue(actionConfig.getAllowedMethods().contains("input")); |
| } |
| |
| /* org.apache.struts2.convention.actions.result */ |
| pkgConfig = configuration.getPackageConfig("org.apache.struts2.convention.actions.result#struts-default#/result"); |
| assertNotNull(pkgConfig); |
| checkSmiValue(pkgConfig, strutsDefault, isSmiInheritanceEnabled); |
| assertEquals(7, pkgConfig.getActionConfigs().size()); |
| verifyActionConfig(pkgConfig, "class-level-result", ClassLevelResultAction.class, "execute", pkgConfig.getName()); |
| verifyActionConfig(pkgConfig, "class-level-results", ClassLevelResultsAction.class, "execute", pkgConfig.getName()); |
| verifyActionConfig(pkgConfig, "action-level-result", ActionLevelResultAction.class, "execute", pkgConfig.getName()); |
| verifyActionConfig(pkgConfig, "action-level-results", ActionLevelResultsAction.class, "execute", pkgConfig.getName()); |
| verifyActionConfig(pkgConfig, "inherited-result-extends", InheritedResultExtends.class, "execute", pkgConfig.getName()); |
| |
| /* org.apache.struts2.convention.actions.resultpath */ |
| pkgConfig = configuration.getPackageConfig("org.apache.struts2.convention.actions.resultpath#struts-default#/resultpath"); |
| assertNotNull(pkgConfig); |
| checkSmiValue(pkgConfig, strutsDefault, isSmiInheritanceEnabled); |
| assertEquals(2, pkgConfig.getActionConfigs().size()); |
| verifyActionConfig(pkgConfig, "class-level-result-path", ClassLevelResultPathAction.class, "execute", pkgConfig.getName()); |
| verifyActionConfig(pkgConfig, "package-level-result-path", PackageLevelResultPathAction.class, "execute", pkgConfig.getName()); |
| |
| /* org.apache.struts2.convention.actions.interceptorRefs */ |
| pkgConfig = configuration.getPackageConfig("org.apache.struts2.convention.actions.interceptor#struts-default#/interceptor"); |
| assertNotNull(pkgConfig); |
| checkSmiValue(pkgConfig, strutsDefault, isSmiInheritanceEnabled); |
| assertEquals(9, pkgConfig.getActionConfigs().size()); |
| verifyActionConfigInterceptors(pkgConfig, "action100", "interceptor-1"); |
| verifyActionConfigInterceptors(pkgConfig, "action200", "interceptor-1", "interceptor-2"); |
| verifyActionConfigInterceptors(pkgConfig, "action300", "interceptor-1", "interceptor-2"); |
| verifyActionConfigInterceptors(pkgConfig, "action400", "interceptor-1", "interceptor-1", "interceptor-2"); |
| |
| // Interceptors at class level |
| verifyActionConfigInterceptors(pkgConfig, "action500", "interceptor-1"); |
| verifyActionConfigInterceptors(pkgConfig, "action600", "interceptor-1", "interceptor-2"); |
| verifyActionConfigInterceptors(pkgConfig, "action700", "interceptor-1", "interceptor-1", "interceptor-2"); |
| |
| //multiple interceptor at class level |
| verifyActionConfigInterceptors(pkgConfig, "action800", "interceptor-1", "interceptor-2"); |
| verifyActionConfigInterceptors(pkgConfig, "action900", "interceptor-1", "interceptor-1", "interceptor-2"); |
| |
| /* org.apache.struts2.convention.actions */ |
| pkgConfig = configuration.getPackageConfig("org.apache.struts2.convention.actions#struts-default#"); |
| assertNotNull(pkgConfig); |
| checkSmiValue(pkgConfig, strutsDefault, isSmiInheritanceEnabled); |
| |
| assertEquals(4, pkgConfig.getActionConfigs().size()); |
| verifyActionConfig(pkgConfig, "no-annotation", NoAnnotationAction.class, "execute", pkgConfig.getName()); |
| verifyActionConfig(pkgConfig, "default-result-path", DefaultResultPathAction.class, "execute", pkgConfig.getName()); |
| verifyActionConfig(pkgConfig, "skip", Skip.class, "execute", pkgConfig.getName()); |
| verifyActionConfig(pkgConfig, "idx", org.apache.struts2.convention.actions.idx.Index.class, "execute", |
| "org.apache.struts2.convention.actions.idx#struts-default#/idx"); |
| |
| /* org.apache.struts2.convention.actions.transactions */ |
| pkgConfig = configuration.getPackageConfig("org.apache.struts2.convention.actions.transactions#struts-default#/transactions"); |
| checkSmiValue(pkgConfig, strutsDefault, isSmiInheritanceEnabled); |
| verifyActionConfig(pkgConfig, "trans1", TransNameAction.class, "trans1", pkgConfig.getName()); |
| verifyActionConfig(pkgConfig, "trans2", TransNameAction.class, "trans2", pkgConfig.getName()); |
| |
| /* org.apache.struts2.convention.actions.exclude */ |
| pkgConfig = configuration.getPackageConfig("org.apache.struts2.convention.actions.exclude#struts-default#/exclude"); |
| if (excludePackages != null && excludePackages.contains("org.apache.struts2.convention.actions.exclude")) { |
| verifyMissingActionConfig(configuration, "exclude1", ExcludeAction.class, "run1", "org.apache.struts2.convention.actions.exclude#struts-default#/exclude"); |
| } else { |
| verifyActionConfig(pkgConfig, "exclude1", ExcludeAction.class, "run1", pkgConfig.getName()); |
| } |
| |
| //test unknown handler automatic chaining |
| pkgConfig = configuration.getPackageConfig("org.apache.struts2.convention.actions.chain#struts-default#/chain"); |
| checkSmiValue(pkgConfig, strutsDefault, isSmiInheritanceEnabled); |
| ServletContext context = EasyMock.createNiceMock(ServletContext.class); |
| EasyMock.replay(context); |
| |
| ObjectFactory workingFactory = configuration.getContainer().getInstance(ObjectFactory.class); |
| ConventionUnknownHandler uh = new ConventionUnknownHandler(configuration, workingFactory, context, mockContainer, "struts-default", null, "-"); |
| ActionContext actionContext = new ActionContext(Collections.EMPTY_MAP); |
| |
| Result result = uh.handleUnknownResult(actionContext, "foo", pkgConfig.getActionConfigs().get("foo"), "bar"); |
| assertNotNull(result); |
| assertTrue(result instanceof ActionChainResult); |
| ActionChainResult chainResult = (ActionChainResult) result; |
| ActionChainResult chainResultToCompare = new ActionChainResult(null, "foo-bar", null); |
| assertEquals(chainResultToCompare, chainResult); |
| } |
| |
| private void verifyActionConfig(PackageConfig pkgConfig, String actionName, Class<?> actionClass, |
| String methodName, String packageName) { |
| ActionConfig ac = pkgConfig.getAllActionConfigs().get(actionName); |
| assertNotNull(ac); |
| assertEquals(actionClass.getName(), ac.getClassName()); |
| assertEquals(methodName, ac.getMethodName()); |
| assertEquals(packageName, ac.getPackageName()); |
| } |
| |
| private void verifyMissingActionConfig(Configuration configuration, String actionName, Class<?> actionClass, |
| String methodName, String packageName) { |
| assertNull(configuration.getPackageConfig(packageName)); |
| assertFalse(configuration.getPackageConfigNames().contains(packageName)); |
| } |
| |
| private void verifyMissingActionConfig(PackageConfig pkgConfig, String actionName, Class<?> actionClass, |
| String methodName, String packageName) { |
| ActionConfig ac = pkgConfig.getAllActionConfigs().get(actionName); |
| assertNull(ac); |
| } |
| |
| private void verifyActionConfig(PackageConfig pkgConfig, String actionName, String actionClass, String methodName, String packageName) { |
| ActionConfig ac = pkgConfig.getAllActionConfigs().get(actionName); |
| assertNotNull(ac); |
| assertEquals(actionClass, ac.getClassName()); |
| assertEquals(methodName, ac.getMethodName()); |
| assertEquals(packageName, ac.getPackageName()); |
| } |
| |
| private void checkSmiValue(PackageConfig pkgConfig, PackageConfig parentConfig, boolean isSmiInheritanceEnabled) { |
| if (isSmiInheritanceEnabled) { |
| assertEquals(parentConfig.isStrictMethodInvocation(), pkgConfig.isStrictMethodInvocation()); |
| } else if (!isSmiInheritanceEnabled && !parentConfig.isStrictMethodInvocation()){ |
| assertTrue(pkgConfig.isStrictMethodInvocation()); |
| } |
| } |
| |
| private void verifyActionConfigInterceptors(PackageConfig pkgConfig, String actionName, String... refs) { |
| ActionConfig ac = pkgConfig.getAllActionConfigs().get(actionName); |
| assertNotNull(ac); |
| List<InterceptorMapping> interceptorMappings = ac.getInterceptors(); |
| for (int i = 0; i < interceptorMappings.size(); i++) { |
| InterceptorMapping interceptorMapping = interceptorMappings.get(i); |
| assertEquals(refs[i], interceptorMapping.getName()); |
| } |
| } |
| |
| private PackageConfig makePackageConfig(String name, String namespace, PackageConfig parent, |
| String defaultResultType, ResultTypeConfig... results) { |
| return makePackageConfig(name, namespace, parent, defaultResultType, results, null, null, null, true); |
| } |
| |
| private PackageConfig makePackageConfig(String name, String namespace, PackageConfig parent, |
| String defaultResultType, ResultTypeConfig[] results, List<InterceptorConfig> interceptors, |
| List<InterceptorStackConfig> interceptorStacks, Set<String> globalAllowedMethods, boolean strictMethodInvocation) { |
| PackageConfig.Builder builder = new PackageConfig.Builder(name); |
| if (namespace != null) { |
| builder.namespace(namespace); |
| } |
| if (parent != null) { |
| builder.addParent(parent); |
| } |
| if (defaultResultType != null) { |
| builder.defaultResultType(defaultResultType); |
| } |
| if (results != null) { |
| for (ResultTypeConfig result : results) { |
| builder.addResultTypeConfig(result); |
| } |
| } |
| if (interceptors != null) { |
| for (InterceptorConfig ref : interceptors) { |
| builder.addInterceptorConfig(ref); |
| } |
| } |
| if (interceptorStacks != null) { |
| for (InterceptorStackConfig ref : interceptorStacks) { |
| builder.addInterceptorStackConfig(ref); |
| } |
| } |
| |
| if (globalAllowedMethods != null) { |
| builder.addGlobalAllowedMethods(globalAllowedMethods); |
| } |
| |
| if (!strictMethodInvocation) { |
| builder.strictMethodInvocation(strictMethodInvocation); |
| } |
| |
| return new MyPackageConfig(builder.build()); |
| } |
| |
| private InterceptorConfig makeInterceptorConfig(String name) { |
| InterceptorConfig.Builder builder = new InterceptorConfig.Builder(name, "org.apache.struts2.convention.TestInterceptor"); |
| return builder.build(); |
| } |
| |
| private InterceptorStackConfig makeInterceptorStackConfig(String name, InterceptorMapping... interceptors) { |
| InterceptorStackConfig.Builder builder = new InterceptorStackConfig.Builder(name); |
| for (InterceptorMapping interceptor : interceptors) |
| builder.addInterceptor(interceptor); |
| return builder.build(); |
| } |
| |
| public class MyPackageConfig extends PackageConfig { |
| protected MyPackageConfig(PackageConfig packageConfig) { |
| super(packageConfig); |
| } |
| |
| public boolean equals(Object obj) { |
| PackageConfig other = (PackageConfig) obj; |
| return getName().equals(other.getName()) && getNamespace().equals(other.getNamespace()) && |
| getParents().get(0) == other.getParents().get(0) && getParents().size() == other.getParents().size(); |
| } |
| } |
| |
| public class DummyContainer implements Container { |
| private ActionNameBuilder actionNameBuilder; |
| private ResultMapBuilder resultMapBuilder; |
| private InterceptorMapBuilder interceptorMapBuilder; |
| private ConventionsService conventionsService; |
| private DefaultFileManagerFactory fileManagerFactory; |
| |
| public DummyContainer() { |
| fileManagerFactory = new DefaultFileManagerFactory(); |
| fileManagerFactory.setContainer(this); |
| fileManagerFactory.setFileManager(new DefaultFileManager()); |
| } |
| |
| public void setActionNameBuilder(ActionNameBuilder actionNameBuilder) { |
| this.actionNameBuilder = actionNameBuilder; |
| } |
| |
| public void setInterceptorMapBuilder(InterceptorMapBuilder interceptorMapBuilder) { |
| this.interceptorMapBuilder = interceptorMapBuilder; |
| } |
| |
| public void setResultMapBuilder(ResultMapBuilder resultMapBuilder) { |
| this.resultMapBuilder = resultMapBuilder; |
| } |
| |
| public void setConventionsService(ConventionsService conventionsService) { |
| this.conventionsService = conventionsService; |
| } |
| |
| public <T> T getInstance(Class<T> type) { |
| try { |
| if (type == FileManagerFactory.class) { |
| return (T) fileManagerFactory; |
| } |
| T obj; |
| if (type == ObjectFactory.class) { |
| obj = type.getConstructor().newInstance(); |
| ((ObjectFactory)obj).setContainer(this); |
| |
| OgnlReflectionProvider rp = new OgnlReflectionProvider() { |
| |
| @Override |
| public void setProperties(Map<String, ?> properties, Object o) { |
| } |
| |
| public void setProperties(Map<String, ?> properties, Object o, Map<String, Object> context, boolean throwPropertyExceptions) throws ReflectionException { |
| if (o instanceof ActionChainResult) { |
| ((ActionChainResult) o).setActionName(String.valueOf(properties.get("actionName"))); |
| } |
| } |
| |
| @Override |
| public void setProperty(String name, Object value, Object o, Map<String, Object> context, boolean throwPropertyExceptions) { |
| if (o instanceof ActionChainResult) { |
| ((ActionChainResult) o).setActionName((String) value); |
| } |
| } |
| }; |
| DefaultInterceptorFactory dif = new DefaultInterceptorFactory(); |
| dif.setObjectFactory((ObjectFactory) obj); |
| dif.setReflectionProvider(rp); |
| |
| DefaultResultFactory drf = new DefaultResultFactory(); |
| drf.setObjectFactory((ObjectFactory) obj); |
| drf.setReflectionProvider(rp); |
| |
| ((ObjectFactory) obj).setInterceptorFactory(dif); |
| ((ObjectFactory) obj).setResultFactory(drf); |
| } else { |
| obj = type.newInstance(); |
| } |
| return obj; |
| } catch (Exception e) { |
| throw new RuntimeException(e); |
| } |
| } |
| |
| public <T> T getInstance(Class<T> type, String name) { |
| if (type == ResultMapBuilder.class) |
| return (T) resultMapBuilder; |
| else if (type == InterceptorMapBuilder.class) |
| return (T) interceptorMapBuilder; |
| else if (type == ActionNameBuilder.class) |
| return (T) actionNameBuilder; |
| else if (type == ConventionsService.class) |
| return (T) conventionsService; |
| else if (type == FileManagerFactory.class) |
| return (T) fileManagerFactory; |
| return null; |
| } |
| |
| public Set<String> getInstanceNames(Class<?> type) { |
| if (type == FileManager.class) { |
| return Collections.emptySet(); |
| } |
| return null; |
| } |
| |
| public void inject(Object o) { |
| |
| } |
| |
| public <T> T inject(Class<T> implementation) { |
| try { |
| return implementation.newInstance(); |
| } catch (Exception e) { |
| return null; |
| } |
| } |
| |
| public void removeScopeStrategy() { |
| |
| } |
| |
| public void setScopeStrategy(Strategy scopeStrategy) { |
| } |
| |
| } |
| } |
