1 package org.weda.action;
2
3 import java.util.HashSet;
4 import java.util.List;
5 import java.util.Set;
6 import org.weda.action.impl.ActionListenerFilterImpl;
7 import org.weda.test.WedaTestCase;
8 import org.weda.action.impl.ActionExecutionContextImpl;
9 import org.weda.message.Messages;
10 import org.weda.message.MessagesRegistry;
11
12 /**
13 *
14 * @author Mikhail Titov
15 */
16 public class ActionRegistryTest extends WedaTestCase
17 implements ActionContainer, ActionPreprocessor
18 {
19 private Set<Class> disabledActions=new HashSet<Class>();
20 private String prepResult = null;
21
22 public ActionRegistryTest(String name) throws Exception {
23 super(name);
24 }
25
26 public void test_actions_configuration_point() throws Exception {
27 List<ActionDescriptor> config=
28 (List<ActionDescriptor>)
29 registry.getConfiguration("org.weda.action.Actions");
30 assertNotNull(config);
31 assertTrue(config.size()>=3);
32 ActionDescriptor desc = findActionByName("test-action", config);
33 assertNotNull(desc);
34 assertEquals("test action description [t]", desc.getDescription());
35 assertEquals("t", desc.getAccessKey());
36 assertEquals("test-action", desc.getName());
37 assertEquals(TestAction.class, desc.getActionClass());
38 assertEquals(1, desc.getTargetClasses().size());
39 assertNull(desc.getTargetFrame());
40 ActionTargetClass targetClass =
41 desc.getTargetClasses().iterator().next();
42 assertNotNull(targetClass);
43 assertEquals(TestActionContainer.class, targetClass.getTargetClass());
44 assertEquals(1, targetClass.getTagetObjectNames().size());
45 assertEquals(
46 "test-action-container"
47 , targetClass.getTagetObjectNames().iterator().next());
48
49 desc = findActionByName("test-action2", config);
50 assertNotNull(desc);
51 assertEquals("_blank", desc.getTargetFrame());
52
53 desc = findActionByName("test-action4", config);
54 assertNotNull(desc);
55 List<LinkedAction> linkedActions = desc.getLinkedActions();
56 assertNotNull(linkedActions);
57 assertEquals(2, linkedActions.size());
58 LinkedAction linkedAction = null;
59 LinkedAction cancelAction = null;
60 for (LinkedAction action: linkedActions){
61 if (TestLinkedAction.class.equals(action.getActionClass()))
62 linkedAction = action;
63 else if (TestCancelLinkedAction.class
64 .equals(action.getActionClass()))
65 {
66 cancelAction = action;
67 }
68 }
69 assertNotNull(linkedAction);
70 assertFalse(linkedAction.isCancelAction());
71 assertNotNull(cancelAction);
72 assertTrue(cancelAction.isCancelAction());
73 }
74
75 public void test_service_point() throws Exception{
76 ActionRegistry actionReg =
77 (ActionRegistry)registry.getService(ActionRegistry.class);
78 assertNotNull(actionReg);
79 }
80
81 public void test_disabled_actions() throws Exception {
82 ActionRegistry actionReg =
83 (ActionRegistry)registry.getService(ActionRegistry.class);
84 TestActionContainer container = new TestActionContainer();
85 container.addDisabledAction(TestAction.class);
86 List<ActionState> descs =
87 actionReg.getActionsStates(container, container.getClass());
88 assertNotNull(descs);
89
90 assertEquals(1, descs.size());
91 }
92
93 public void test_getActionsStates() throws Exception {
94 ActionRegistry actionReg =
95 (ActionRegistry)registry.getService(ActionRegistry.class);
96 ActionContainer actionContainer = new TestActionContainer();
97 List<ActionState> states =
98 actionReg.getActionsStates(
99 actionContainer, actionContainer.getClass());
100 ActionState state = null;
101 for (ActionState actionState: states)
102 if ("test-action".equals(
103 actionState.getActionDescriptor().getName()))
104 {
105 state=actionState;
106 break;
107 }
108 assertNotNull(state);
109 assertEquals(10, state.getParameterValues().get("readOnlyParameter"));
110 assertEquals("value", state.getParameterValues().get("readWriteParameter"));
111 assertEquals("read only parameter"
112 , state.getActionDescriptor()
113 .getActionParameter("readOnlyParameter")
114 .getDisplayName());
115 }
116
117 public void test_getLastExecutedActionInfo_phase1() throws Exception {
118 ActionRegistry actionReg =
119 (ActionRegistry)registry.getService(ActionRegistry.class);
120 ExecutedActionInfo actionInfo = actionReg.getLastExecutedActionInfo();
121 assertNotNull(actionInfo);
122 assertTrue(actionInfo.isSuccessExecution());
123 }
124
125 public void test_execute_action() throws Exception {
126 ActionContainer actionContainer = new TestActionContainer();
127 checkExecute(actionContainer, "test-action");
128 }
129
130 public void test_set_parameter_value_from_config() throws Exception {
131 ActionContainer actionContainer = new TestActionContainer7();
132 ActionRegistry actionReg =
133 (ActionRegistry)registry.getService(ActionRegistry.class);
134 assertTrue(
135 actionReg.hasRegisteredActions(
136 actionContainer.getClass(), actionContainer));
137 List<ActionState> states =
138 actionReg.getActionsStates(
139 actionContainer, actionContainer.getClass());
140 assertNotNull(states);
141
142 ActionDescriptor desc =
143 getDescriptorByName("test-parameter-action", states);
144 assertNotNull(desc);
145 assertNotNull(desc.getActionParameters());
146 ActionExecutionContextImpl ctx =
147 new ActionExecutionContextImpl();
148 ctx.setTargetObject(actionContainer);
149 ctx.setActionDescriptor(states.get(0).getActionDescriptor());
150 Object actionRes = actionReg.executeAction(ctx).getActionResult();
151 assertEquals(10, actionRes);
152 }
153
154 public void test_execute_target_class_global_action() throws Exception {
155 ActionContainer actionContainer = new TestActionContainer2();
156 checkExecute(actionContainer, "test-action2");
157 }
158
159 public void test_execute_global_action() throws Exception {
160 ActionContainer actionContainer = new TestActionContainer6();
161 checkExecute(actionContainer, "test-action3");
162 }
163
164 public void test_action_messages() throws Exception {
165 ActionRegistry reg =
166 (ActionRegistry)registry.getService(ActionRegistry.class);
167 List<ActionState> states = reg.getActionsStates(
168 new TestActionContainer6(), TestActionContainer.class);
169 assertNotNull(states);
170 ActionDescriptor testActionDesc = null;
171 for (ActionState state: states)
172 if (state.getActionDescriptor().getName().equals("test-action3")){
173 testActionDesc=state.getActionDescriptor();
174 break;
175 }
176 assertEquals("T", testActionDesc.getAccessKey());
177 assertNotNull(testActionDesc);
178 }
179
180 public void test_getLastExecutedActionInfo_phase2() throws Exception {
181 ActionContainer actionContainer = new TestActionContainer();
182 ActionRegistry actionReg =
183 (ActionRegistry)registry.getService(ActionRegistry.class);
184 checkExecute(actionContainer, "test-action");
185 ExecutedActionInfo actionInfo = actionReg.getLastExecutedActionInfo();
186 assertNotNull(actionInfo);
187 assertTrue(actionInfo.isSuccessExecution());
188 assertEquals(TestAction.class, actionInfo.getActionClass());
189 assertEquals(actionContainer.getClass(), actionInfo.getTargetClass());
190 assertEquals(actionContainer.getActionContainerName(), actionInfo.getTargetName());
191 assertEquals(
192 "paramValue:"+actionContainer.getClass().getName()
193 +":paramValue2"
194 , actionInfo.getActionResult());
195 }
196
197 public void test_linkedAction() throws Exception {
198 checkLinkedActionExecute("linked-action", false);
199 checkLinkedActionExecute("cancel-action", true);
200 }
201
202 public void test_multiLeveledLinkedAction() throws Exception {
203 ActionRegistry reg =
204 (ActionRegistry)registry.getService(ActionRegistry.class);
205 TestActionContainer5 rootContainer = new TestActionContainer5();
206 List<ActionState> states =
207 reg.getActionsStates(rootContainer, rootContainer.getClass());
208 assertNotNull(states);
209 ActionDescriptor desc = getDescriptorByName("test-action5", states);
210 assertNotNull(desc);
211 ActionExecutionContextImpl ctx = new ActionExecutionContextImpl();
212 ctx.setActionDescriptor(desc);
213 ctx.setTargetObject(rootContainer);
214 reg.executeAction(ctx);
215 ExecutedActionInfo info = reg.getLastExecutedActionInfo();
216
217 TestActionContainer4 container = new TestActionContainer4();
218 states =
219 reg.getActionsStates(container, container.getClass());
220 assertNotNull(states);
221
222 desc = getDescriptorByName("test-action4", states);
223 assertNotNull(desc);
224 ctx = new ActionExecutionContextImpl();
225 ctx.setActionDescriptor(desc);
226 ctx.setTargetObject(container);
227 reg.executeAction(ctx);
228 assertTrue(rootContainer.isExecuted());
229 assertFalse(rootContainer.isLinkActionExecuted());
230
231 ActionContainer container2 = new TestActionContainer();
232 checkExecute(container2, "test-action");
233 assertTrue(rootContainer.isExecuted());
234 assertFalse(rootContainer.isLinkActionExecuted());
235
236 TestActionContainer3 container3 = new TestActionContainer3();
237 states = reg.getActionsStates(container3, container3.getClass());
238 assertNotNull(states);
239
240 desc = getDescriptorByName("linked-action", states);
241 assertNotNull(desc);
242 ctx = new ActionExecutionContextImpl();
243 ctx.setActionDescriptor(desc);
244 ctx.setTargetObject(container3);
245 reg.executeAction(ctx);
246 assertEquals(info, reg.getLastExecutedActionInfo());
247 assertTrue(container.isExecuted());
248 assertTrue(container.isLinkActionExecuted());
249 assertFalse(container.isCancelAction());
250 assertTrue(rootContainer.isExecuted());
251 assertTrue(rootContainer.isLinkActionExecuted());
252 assertFalse(rootContainer.isCancelAction());
253 }
254
255 public void test_DynamicActionListener() throws Exception {
256 ActionRegistry reg =
257 (ActionRegistry)registry.getService(ActionRegistry.class);
258 TestActionListener listener = new TestActionListener();
259 assertFalse(listener.isAfterExecuteExecuted());
260 assertFalse(listener.isBeforeExecuteExecuted());
261
262 reg.addActionListener(listener);
263 ActionContainer actionContainer = new TestActionContainer();
264 checkExecute(actionContainer, "test-action");
265 assertTrue(listener.isAfterExecuteExecuted());
266 assertTrue(listener.isBeforeExecuteExecuted());
267
268 listener.resetState();
269 reg.removeActionListener(listener);
270 checkExecute(actionContainer, "test-action");
271 assertFalse(listener.isAfterExecuteExecuted());
272 assertFalse(listener.isBeforeExecuteExecuted());
273
274 }
275
276 public void test_DynamicActionListener_withFilter() throws Exception {
277 ActionRegistry reg =
278 (ActionRegistry)registry.getService(ActionRegistry.class);
279 ActionListenerFilter filter =
280 new ActionListenerFilterImpl(null, TestActionContainer.class);
281 ActionListenerFilter filter2 =
282 new ActionListenerFilterImpl(TestAction5.class, null);
283 ActionListenerFilterImpl filter3 =
284 new ActionListenerFilterImpl();
285 filter3.addTargetName("test-action-container");
286 ActionListenerFilterImpl filter4 =
287 new ActionListenerFilterImpl();
288 filter4.addTargetName("test-action-container5");
289
290 TestActionListener listener = new TestActionListener(filter);
291 TestActionListener listener2 = new TestActionListener(filter2);
292 TestActionListener listener3 = new TestActionListener(filter3);
293 TestActionListener listener4 = new TestActionListener(filter4);
294 reg.addActionListener(listener);
295 reg.addActionListener(listener2);
296 reg.addActionListener(listener3);
297 reg.addActionListener(listener4);
298 ActionContainer actionContainer = new TestActionContainer();
299 checkExecute(actionContainer, "test-action");
300 assertTrue(listener.isAfterExecuteExecuted());
301 assertTrue(listener.isBeforeExecuteExecuted());
302 assertFalse(listener2.isAfterExecuteExecuted());
303 assertFalse(listener2.isBeforeExecuteExecuted());
304 assertTrue(listener3.isAfterExecuteExecuted());
305 assertTrue(listener3.isBeforeExecuteExecuted());
306 assertFalse(listener4.isAfterExecuteExecuted());
307 assertFalse(listener4.isBeforeExecuteExecuted());
308
309 listener.resetState();
310 listener2.resetState();
311 checkExecute(new TestActionContainer(), "test-action5");
312 assertTrue(listener.isAfterExecuteExecuted());
313 assertTrue(listener.isBeforeExecuteExecuted());
314 assertTrue(listener2.isAfterExecuteExecuted());
315 assertTrue(listener2.isBeforeExecuteExecuted());
316
317 }
318
319 public void test_actionListener_fromConfig() throws Exception{
320 ActionRegistry reg =
321 (ActionRegistry)registry.getService(ActionRegistry.class);
322 ActionListenerService serv =
323 (ActionListenerService)registry.getService(
324 "org.weda.test.ActionListenerService"
325 , ActionListenerService.class);
326
327 assertNotNull(serv);
328 ActionListenerFilter filter = serv.getFilter();
329 assertNotNull(filter);
330 assertEquals(TestAction.class, filter.getActionClass());
331 assertEquals(TestActionContainer.class, filter.getTargetClass());
332 Set<String> targetNames = filter.getTargetNames();
333 assertNotNull(targetNames);
334 assertEquals(1, targetNames.size());
335 assertTrue(targetNames.contains("test-action-container"));
336
337 assertTrue(serv.isAfterExecuteExecuted());
338 assertTrue(serv.isBeforeExecuteExecuted());
339 }
340
341 private void checkLinkedActionExecute(
342 String linkedActionName, boolean cancelAction)
343 throws Exception
344 {
345 TestActionContainer4 container = new TestActionContainer4();
346 ActionRegistry reg =
347 (ActionRegistry)registry.getService(ActionRegistry.class);
348 List<ActionState> states =
349 reg.getActionsStates(container, container.getClass());
350 assertNotNull(states);
351
352 ActionDescriptor desc = getDescriptorByName("test-action4", states);
353 assertNotNull(desc);
354 ActionExecutionContextImpl ctx = new ActionExecutionContextImpl();
355 ctx.setActionDescriptor(desc);
356 ctx.setTargetObject(container);
357 reg.executeAction(ctx);
358 ExecutedActionInfo info = reg.getLastExecutedActionInfo();
359 assertTrue(container.isExecuted());
360 assertFalse(container.isLinkActionExecuted());
361
362 ActionContainer container2 = new TestActionContainer();
363 checkExecute(container2, "test-action");
364 assertTrue(container.isExecuted());
365 assertFalse(container.isLinkActionExecuted());
366
367 TestActionContainer3 container3 = new TestActionContainer3();
368 states = reg.getActionsStates(container3, container3.getClass());
369 assertNotNull(states);
370
371 desc = getDescriptorByName(linkedActionName, states);
372 assertNotNull(desc);
373 ctx = new ActionExecutionContextImpl();
374 ctx.setActionDescriptor(desc);
375 ctx.setTargetObject(container3);
376 reg.executeAction(ctx);
377 assertEquals(info, reg.getLastExecutedActionInfo());
378 assertTrue(container.isExecuted());
379 assertTrue(container.isLinkActionExecuted());
380 assertEquals(cancelAction, container.isCancelAction());
381 }
382
383 public ExecutedActionInfo executeAction(ActionExecutionContext context)
384 throws ActionRegistryException
385 {
386 return null;
387 }
388
389 public Set<Class> getDisabledActions() {
390 return disabledActions;
391 }
392
393 public List<ActionState> getActionsStates()
394 throws ActionRegistryException
395 {
396 return null;
397 }
398
399 public boolean hasRegisteredActions() {
400 return false;
401 }
402
403 protected void checkExecute(
404 ActionContainer actionContainer, String actionName)
405 throws Exception
406 {
407 ActionRegistry actionReg =
408 (ActionRegistry)registry.getService(ActionRegistry.class);
409 assertTrue(
410 actionReg.hasRegisteredActions(
411 actionContainer.getClass(), actionContainer));
412 List<ActionState> states =
413 actionReg.getActionsStates(
414 actionContainer, actionContainer.getClass());
415 assertNotNull(states);
416
417 ActionDescriptor desc = getDescriptorByName(actionName, states);
418 assertNotNull(desc);
419 assertNotNull(desc.getActionParameters());
420 assertEquals(3, desc.getActionParameters().size());
421 ActionExecutionContextImpl ctx =
422 new ActionExecutionContextImpl();
423 ctx.setActionDescriptor(desc);
424 ctx.setActionParameterValue("parameter", "paramValue");
425 ctx.setActionParameterValue("readWriteParameter", "paramValue2");
426 ctx.setTargetObject(actionContainer);
427 Object actionRes = actionReg.executeAction(ctx).getActionResult();
428 assertEquals(
429 "paramValue:"+actionContainer.getClass().getName()+":paramValue2", actionRes);
430 }
431
432 public Object prepropecessAction(ActionExecutionContext context) {
433 prepResult="PREPROCESSED";
434 assertNotNull(context);
435 return null;
436 }
437
438 private ActionDescriptor findActionByName(
439 String actionName, List<ActionDescriptor> descriptors)
440 {
441 Messages messages = (Messages)registry.getService(MessagesRegistry.class);
442 ActionDescriptor desc = null;
443 for(ActionDescriptor d: descriptors){
444 d.setMessages(messages);
445 if (actionName.equals(d.getName())){
446 desc=d;
447 break;
448 }
449 }
450 return desc;
451 }
452
453 public String getActionContainerName() {
454 return "ActionRegistryTest";
455 }
456
457 }