1
2
3
4
5
6
7
8
9
10
11
12
13 package com.eviware.soapui.monitor;
14
15 import java.util.HashSet;
16 import java.util.Iterator;
17 import java.util.Set;
18
19 import com.eviware.soapui.model.project.Project;
20 import com.eviware.soapui.model.support.LoadTestRunListenerAdapter;
21 import com.eviware.soapui.model.support.ProjectListenerAdapter;
22 import com.eviware.soapui.model.support.TestRunListenerAdapter;
23 import com.eviware.soapui.model.support.TestSuiteListenerAdapter;
24 import com.eviware.soapui.model.support.WorkspaceListenerAdapter;
25 import com.eviware.soapui.model.testsuite.LoadTest;
26 import com.eviware.soapui.model.testsuite.LoadTestRunContext;
27 import com.eviware.soapui.model.testsuite.LoadTestRunner;
28 import com.eviware.soapui.model.testsuite.TestCase;
29 import com.eviware.soapui.model.testsuite.TestRunContext;
30 import com.eviware.soapui.model.testsuite.TestRunner;
31 import com.eviware.soapui.model.testsuite.TestSuite;
32 import com.eviware.soapui.model.workspace.Workspace;
33
34 /***
35 * Global class for monitoring ongoing test runs (both functional and loadtests)
36 *
37 * @author Ole.Matzura
38 */
39
40 public class TestMonitor
41 {
42 private Set<TestMonitorListener> listeners = new HashSet<TestMonitorListener>();
43 private InternalWorkspaceListener workspaceListener = new InternalWorkspaceListener();
44 private InternalProjectListener projectListener = new InternalProjectListener();
45 private InternalTestSuiteListener testSuiteListener = new InternalTestSuiteListener();
46 private InternalTestRunListener testRunListener = new InternalTestRunListener();
47 private InternalLoadTestRunListener loadTestRunListener = new InternalLoadTestRunListener();
48 private Set<TestRunner> runningTestCases = new HashSet<TestRunner>();
49 private Set<LoadTestRunner> runningLoadTests = new HashSet<LoadTestRunner>();
50
51 public TestMonitor()
52 {
53 }
54
55 protected void notifyLoadTestStarted( LoadTestRunner runner )
56 {
57 runningLoadTests.add( runner );
58
59 if( listeners.isEmpty() )
60 return;
61
62 TestMonitorListener [] l = listeners.toArray( new TestMonitorListener[listeners.size()]);
63 for( int c = 0; c < l.length; c++ )
64 {
65 l[c].loadTestStarted( runner );
66 }
67 }
68
69 protected void notifyLoadTestFinished( LoadTestRunner runner )
70 {
71 runningLoadTests.remove( runner.getLoadTest().getTestCase() );
72
73 if( listeners.isEmpty() )
74 return;
75
76 TestMonitorListener [] l = listeners.toArray( new TestMonitorListener[listeners.size()]);
77 for( int c = 0; c < l.length; c++ )
78 {
79 l[c].loadTestFinished( runner );
80 }
81 }
82
83 protected void notifyTestCaseStarted( TestRunner runner )
84 {
85 if( listeners.isEmpty() )
86 return;
87
88 TestMonitorListener [] l = listeners.toArray( new TestMonitorListener[listeners.size()]);
89 for( int c = 0; c < l.length; c++ )
90 {
91 l[c].testCaseStarted( runner );
92 }
93 }
94
95 protected void notifyTestCaseFinished( TestRunner runner )
96 {
97 if( listeners.isEmpty() )
98 return;
99
100 TestMonitorListener [] l = listeners.toArray( new TestMonitorListener[listeners.size()]);
101 for( int c = 0; c < l.length; c++ )
102 {
103 l[c].testCaseFinished( runner );
104 }
105 }
106
107 public boolean hasRunningLoadTest( TestCase testCase )
108 {
109 Iterator<LoadTestRunner> iterator = runningLoadTests.iterator();
110 while( iterator.hasNext() )
111 {
112 if( iterator.next().getLoadTest().getTestCase() == testCase )
113 return true;
114 }
115
116 return false;
117 }
118
119 public boolean hasRunningTestCase( TestCase testCase )
120 {
121 Iterator<TestRunner> iterator = runningTestCases.iterator();
122 while( iterator.hasNext() )
123 {
124 if( iterator.next().getTestCase() == testCase )
125 return true;
126 }
127
128 return false;
129 }
130
131 public void addTestMonitorListener( TestMonitorListener listener )
132 {
133 listeners.add( listener );
134 }
135
136 public void removeTestMonitorListener( TestMonitorListener listener )
137 {
138 listeners.remove( listener );
139 }
140
141 private class InternalWorkspaceListener extends WorkspaceListenerAdapter
142 {
143 public void projectRemoved(Project project)
144 {
145 unmonitorProject(project);
146 }
147
148 public void projectAdded(Project project)
149 {
150 monitorProject( project );
151 }
152 }
153
154 private class InternalProjectListener extends ProjectListenerAdapter
155 {
156 public void testSuiteRemoved(TestSuite testSuite)
157 {
158 unmonitorTestSuite( testSuite );
159 }
160
161 public void testSuiteAdded(TestSuite testSuite)
162 {
163 monitorTestSuite( testSuite );
164 }
165 }
166
167 private class InternalTestSuiteListener extends TestSuiteListenerAdapter
168 {
169 public void testCaseAdded(TestCase testCase)
170 {
171 monitorTestCase( testCase );
172 }
173
174 public void testCaseRemoved(TestCase testCase)
175 {
176 unmonitorTestCase(testCase);
177 }
178
179 public void loadTestAdded(LoadTest loadTest)
180 {
181 monitorLoadTest(loadTest);
182 }
183
184 public void loadTestRemoved(LoadTest loadTest)
185 {
186 unmonitorLoadTest(loadTest);
187 }
188 }
189
190 private class InternalTestRunListener extends TestRunListenerAdapter
191 {
192 public void afterRun(TestRunner testRunner, TestRunContext runContext )
193 {
194 runningTestCases.remove( testRunner );
195 notifyTestCaseFinished( testRunner );
196 }
197
198 public void beforeRun( TestRunner testRunner, TestRunContext runContext )
199 {
200 runningTestCases.add( testRunner );
201 notifyTestCaseStarted( testRunner );
202 }
203 }
204
205 private class InternalLoadTestRunListener extends LoadTestRunListenerAdapter
206 {
207 public void afterLoadTest(LoadTestRunner testRunner, LoadTestRunContext context)
208 {
209 runningLoadTests.remove( testRunner );
210 notifyLoadTestFinished( testRunner );
211 }
212
213 public void beforeLoadTest(LoadTestRunner testRunner, LoadTestRunContext context)
214 {
215 runningLoadTests.add( testRunner );
216 notifyLoadTestStarted( testRunner );
217 }
218 }
219
220 public LoadTestRunner[] getRunningLoadTest()
221 {
222 return runningLoadTests.toArray( new LoadTestRunner[runningLoadTests.size()]);
223 }
224
225 public boolean hasRunningTest(TestCase testCase)
226 {
227 return hasRunningLoadTest( testCase ) || hasRunningTestCase( testCase );
228 }
229
230 public void init(Workspace workspace)
231 {
232 for( int c = 0; c < workspace.getProjectCount(); c++ )
233 {
234 Project project = workspace.getProjectAt( c );
235 monitorProject(project);
236 }
237
238 workspace.addWorkspaceListener( workspaceListener );
239 }
240
241 public void monitorProject(Project project)
242 {
243 project.addProjectListener( projectListener );
244
245 for( int i = 0; i < project.getTestSuiteCount(); i++ )
246 {
247 monitorTestSuite(project.getTestSuiteAt( i ));
248 }
249 }
250
251 private void monitorTestSuite(TestSuite testSuite)
252 {
253 testSuite.addTestSuiteListener( testSuiteListener );
254
255 for( int j = 0; j < testSuite.getTestCaseCount(); j++ )
256 {
257 monitorTestCase( testSuite.getTestCaseAt( j ));
258 }
259 }
260
261 private void monitorTestCase(TestCase testCase)
262 {
263 testCase.addTestRunListener( testRunListener );
264
265 for( int v = 0; v < testCase.getLoadTestCount(); v++ )
266 {
267 testCase.getLoadTestAt( v ).addLoadTestRunListener( loadTestRunListener );
268 }
269 }
270
271 private void monitorLoadTest(LoadTest loadTest)
272 {
273 loadTest.addLoadTestRunListener( loadTestRunListener );
274 }
275
276 public void unmonitorProject(Project project)
277 {
278 project.removeProjectListener( projectListener );
279
280 for( int c = 0; c < project.getTestSuiteCount(); c++ )
281 {
282 TestSuite testSuite = project.getTestSuiteAt( c );
283 unmonitorTestSuite(testSuite);
284 }
285 }
286
287 private void unmonitorTestSuite(TestSuite testSuite)
288 {
289 testSuite.removeTestSuiteListener( testSuiteListener );
290
291 for( int j = 0; j < testSuite.getTestCaseCount(); j++ )
292 {
293 TestCase testCase = testSuite.getTestCaseAt( j );
294 unmonitorTestCase( testCase );
295 }
296 }
297
298 private void unmonitorTestCase(TestCase testCase)
299 {
300 testCase.removeTestRunListener( testRunListener );
301
302 for( int c = 0; c < testCase.getLoadTestCount(); c++ )
303 {
304 unmonitorLoadTest( testCase.getLoadTestAt( c ) );
305 }
306 }
307
308 private void unmonitorLoadTest(LoadTest loadTest)
309 {
310 loadTest.removeLoadTestRunListener( loadTestRunListener );
311 }
312 }