use of com.opensymphony.xwork2.ActionChainResult in project struts by apache.
the class ChainResultTest method testNamespaceAndActionExpressionEvaluation.
public void testNamespaceAndActionExpressionEvaluation() throws Exception {
ActionChainResult result = new ActionChainResult();
result.setActionName("${actionName}");
result.setNamespace("${namespace}");
String expectedActionName = "testActionName";
String expectedNamespace = "testNamespace";
Map<String, Object> values = new HashMap<>();
values.put("actionName", expectedActionName);
values.put("namespace", expectedNamespace);
ValueStack stack = ActionContext.getContext().getValueStack();
stack.push(values);
Mock actionProxyMock = new Mock(ActionProxy.class);
actionProxyMock.matchAndReturn("getActionName", expectedActionName);
actionProxyMock.matchAndReturn("getMethod", "execute");
actionProxyMock.expect("execute");
ActionProxyFactory testActionProxyFactory = new NamespaceActionNameTestActionProxyFactory(expectedNamespace, expectedActionName, (ActionProxy) actionProxyMock.proxy());
result.setActionProxyFactory(testActionProxyFactory);
ActionProxy actionProxy = (ActionProxy) actionProxyMock.proxy();
result.setActionProxyFactory(testActionProxyFactory);
Mock invocationMock = new Mock(ActionInvocation.class);
invocationMock.matchAndReturn("getProxy", actionProxy);
invocationMock.matchAndReturn("getInvocationContext", ActionContext.getContext());
result.execute((ActionInvocation) invocationMock.proxy());
actionProxyMock.verify();
}
use of com.opensymphony.xwork2.ActionChainResult in project struts by apache.
the class ChainResultTest method testWithNoNamespace.
public void testWithNoNamespace() throws Exception {
ActionChainResult result = new ActionChainResult();
result.setActionName("${actionName}");
String expectedActionName = "testActionName";
String expectedNamespace = "${1-1}";
Map<String, Object> values = new HashMap<>();
values.put("actionName", expectedActionName);
ValueStack stack = ActionContext.getContext().getValueStack();
stack.push(values);
Mock actionProxyMock = new Mock(ActionProxy.class);
actionProxyMock.expect("execute");
actionProxyMock.expectAndReturn("getNamespace", expectedNamespace);
actionProxyMock.expectAndReturn("getActionName", expectedActionName);
actionProxyMock.expectAndReturn("getMethod", null);
ActionProxy actionProxy = (ActionProxy) actionProxyMock.proxy();
ActionProxyFactory testActionProxyFactory = new NamespaceActionNameTestActionProxyFactory(expectedNamespace, expectedActionName, actionProxy);
result.setActionProxyFactory(testActionProxyFactory);
Mock invocationMock = new Mock(ActionInvocation.class);
invocationMock.matchAndReturn("getProxy", actionProxy);
invocationMock.matchAndReturn("getInvocationContext", ActionContext.getContext());
try {
ActionContext.bind(stack.getActionContext());
result.execute((ActionInvocation) invocationMock.proxy());
actionProxyMock.verify();
} finally {
ActionContext.clear();
}
}
use of com.opensymphony.xwork2.ActionChainResult in project struts by apache.
the class PackageBasedActionConfigBuilderTest method run.
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;
// 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);
// 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 = ActionContext.of(Collections.emptyMap()).bind();
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);
}
use of com.opensymphony.xwork2.ActionChainResult in project struts by apache.
the class DefaultActionInvocationTester method testActionChainResult.
public void testActionChainResult() throws Exception {
ActionProxy actionProxy = actionProxyFactory.createActionProxy("", "Foo", null, new HashMap<String, Object>());
DefaultActionInvocation defaultActionInvocation = (DefaultActionInvocation) actionProxy.getInvocation();
defaultActionInvocation.init(actionProxy);
SimpleAction action = (SimpleAction) defaultActionInvocation.getAction();
action.setFoo(1);
action.setBar(2);
defaultActionInvocation.invoke();
// then
assertTrue(defaultActionInvocation.result instanceof ActionChainResult);
Result result = defaultActionInvocation.getResult();
assertTrue(result instanceof MockResult);
}
Aggregations