View Javadoc

1   /*
2    *  soapUI, copyright (C) 2004-2007 eviware.com 
3    *
4    *  soapUI is free software; you can redistribute it and/or modify it under the 
5    *  terms of version 2.1 of the GNU Lesser General Public License as published by 
6    *  the Free Software Foundation.
7    *
8    *  soapUI is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without 
9    *  even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 
10   *  See the GNU Lesser General Public License for more details at gnu.org.
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.impl.wsdl.WsdlProject;
20  import com.eviware.soapui.model.mock.MockRunner;
21  import com.eviware.soapui.model.mock.MockService;
22  import com.eviware.soapui.model.project.Project;
23  import com.eviware.soapui.model.support.LoadTestRunListenerAdapter;
24  import com.eviware.soapui.model.support.MockRunListenerAdapter;
25  import com.eviware.soapui.model.support.ProjectListenerAdapter;
26  import com.eviware.soapui.model.support.TestRunListenerAdapter;
27  import com.eviware.soapui.model.support.TestSuiteListenerAdapter;
28  import com.eviware.soapui.model.support.WorkspaceListenerAdapter;
29  import com.eviware.soapui.model.testsuite.LoadTest;
30  import com.eviware.soapui.model.testsuite.LoadTestRunContext;
31  import com.eviware.soapui.model.testsuite.LoadTestRunner;
32  import com.eviware.soapui.model.testsuite.TestCase;
33  import com.eviware.soapui.model.testsuite.TestRunContext;
34  import com.eviware.soapui.model.testsuite.TestRunner;
35  import com.eviware.soapui.model.testsuite.TestSuite;
36  import com.eviware.soapui.model.workspace.Workspace;
37  
38  /***
39   * Global class for monitoring ongoing test runs (both functional and loadtests)
40   * 
41   * @author Ole.Matzura
42   */
43  
44  public class TestMonitor
45  {
46  	private Set<TestMonitorListener> listeners = new HashSet<TestMonitorListener>();
47  	private InternalWorkspaceListener workspaceListener = new InternalWorkspaceListener();
48  	private InternalProjectListener projectListener = new InternalProjectListener();
49  	private InternalTestSuiteListener testSuiteListener = new InternalTestSuiteListener();
50  	private InternalTestRunListener testRunListener = new InternalTestRunListener();
51  	private InternalMockRunListener mockRunListener = new InternalMockRunListener();
52  	private InternalLoadTestRunListener loadTestRunListener = new InternalLoadTestRunListener();
53  	private Set<TestRunner> runningTestCases = new HashSet<TestRunner>();
54  	private Set<LoadTestRunner> runningLoadTests = new HashSet<LoadTestRunner>();
55  	private Set<MockRunner> runningMockServices = new HashSet<MockRunner>();
56  
57  	public TestMonitor()
58  	{
59  	}
60  
61  	protected void notifyLoadTestStarted( LoadTestRunner runner )
62  	{
63  		runningLoadTests.add( runner );
64  
65  		if( listeners.isEmpty() )
66  			return;
67  
68  		TestMonitorListener[] l = listeners.toArray( new TestMonitorListener[listeners.size()] );
69  		for( int c = 0; c < l.length; c++ )
70  		{
71  			l[c].loadTestStarted( runner );
72  		}
73  	}
74  
75  	protected void notifyLoadTestFinished( LoadTestRunner runner )
76  	{
77  		runningLoadTests.remove( runner.getLoadTest().getTestCase() );
78  
79  		if( listeners.isEmpty() )
80  			return;
81  
82  		TestMonitorListener[] l = listeners.toArray( new TestMonitorListener[listeners.size()] );
83  		for( int c = 0; c < l.length; c++ )
84  		{
85  			l[c].loadTestFinished( runner );
86  		}
87  	}
88  
89  	protected void notifyTestCaseStarted( TestRunner runner )
90  	{
91  		if( listeners.isEmpty() )
92  			return;
93  
94  		TestMonitorListener[] l = listeners.toArray( new TestMonitorListener[listeners.size()] );
95  		for( int c = 0; c < l.length; c++ )
96  		{
97  			l[c].testCaseStarted( runner );
98  		}
99  	}
100 
101 	protected void notifyTestCaseFinished( TestRunner runner )
102 	{
103 		if( listeners.isEmpty() )
104 			return;
105 
106 		TestMonitorListener[] l = listeners.toArray( new TestMonitorListener[listeners.size()] );
107 		for( int c = 0; c < l.length; c++ )
108 		{
109 			l[c].testCaseFinished( runner );
110 		}
111 	}
112 
113 	protected void notifyMockServiceStarted( MockRunner runner )
114 	{
115 		if( listeners.isEmpty() )
116 			return;
117 
118 		TestMonitorListener[] l = listeners.toArray( new TestMonitorListener[listeners.size()] );
119 		for( int c = 0; c < l.length; c++ )
120 		{
121 			l[c].mockServiceStarted( runner );
122 		}
123 	}
124 
125 	protected void notifyMockServiceStopped( MockRunner runner )
126 	{
127 		if( listeners.isEmpty() )
128 			return;
129 
130 		TestMonitorListener[] l = listeners.toArray( new TestMonitorListener[listeners.size()] );
131 		for( int c = 0; c < l.length; c++ )
132 		{
133 			l[c].mockServiceStopped( runner );
134 		}
135 	}
136 
137 	public boolean hasRunningLoadTest( TestCase testCase )
138 	{
139 		Iterator<LoadTestRunner> iterator = runningLoadTests.iterator();
140 		while( iterator.hasNext() )
141 		{
142 			if( iterator.next().getLoadTest().getTestCase() == testCase )
143 				return true;
144 		}
145 
146 		return false;
147 	}
148 
149 	public boolean hasRunningTestCase( TestCase testCase )
150 	{
151 		Iterator<TestRunner> iterator = runningTestCases.iterator();
152 		while( iterator.hasNext() )
153 		{
154 			if( iterator.next().getTestCase() == testCase )
155 				return true;
156 		}
157 
158 		return false;
159 	}
160 
161 	public void addTestMonitorListener( TestMonitorListener listener )
162 	{
163 		listeners.add( listener );
164 	}
165 
166 	public void removeTestMonitorListener( TestMonitorListener listener )
167 	{
168 		listeners.remove( listener );
169 	}
170 
171 	private class InternalWorkspaceListener extends WorkspaceListenerAdapter
172 	{
173 		public void projectRemoved( Project project )
174 		{
175 			unmonitorProject( project );
176 		}
177 
178 		public void projectAdded( Project project )
179 		{
180 			monitorProject( project );
181 		}
182 	}
183 
184 	private class InternalProjectListener extends ProjectListenerAdapter
185 	{
186 		public void testSuiteRemoved( TestSuite testSuite )
187 		{
188 			unmonitorTestSuite( testSuite );
189 		}
190 
191 		public void testSuiteAdded( TestSuite testSuite )
192 		{
193 			monitorTestSuite( testSuite );
194 		}
195 
196 		@Override
197 		public void mockServiceAdded( MockService mockService )
198 		{
199 			monitorMockService( mockService );
200 		}
201 
202 		@Override
203 		public void mockServiceRemoved( MockService mockService )
204 		{
205 			unmonitorMockService( mockService );
206 		}
207 	}
208 
209 	private class InternalTestSuiteListener extends TestSuiteListenerAdapter
210 	{
211 		public void testCaseAdded( TestCase testCase )
212 		{
213 			monitorTestCase( testCase );
214 		}
215 
216 		public void testCaseRemoved( TestCase testCase )
217 		{
218 			unmonitorTestCase( testCase );
219 		}
220 
221 		public void loadTestAdded( LoadTest loadTest )
222 		{
223 			monitorLoadTest( loadTest );
224 		}
225 
226 		public void loadTestRemoved( LoadTest loadTest )
227 		{
228 			unmonitorLoadTest( loadTest );
229 		}
230 	}
231 
232 	private class InternalTestRunListener extends TestRunListenerAdapter
233 	{
234 		public void afterRun( TestRunner testRunner, TestRunContext runContext )
235 		{
236 			runningTestCases.remove( testRunner );
237 			notifyTestCaseFinished( testRunner );
238 		}
239 
240 		public void beforeRun( TestRunner testRunner, TestRunContext runContext )
241 		{
242 			runningTestCases.add( testRunner );
243 			notifyTestCaseStarted( testRunner );
244 		}
245 	}
246 
247 	private class InternalMockRunListener extends MockRunListenerAdapter
248 	{
249 		@Override
250 		public void onMockRunnerStart( MockRunner mockRunner )
251 		{
252 			runningMockServices.add( mockRunner );
253 			notifyMockServiceStarted( mockRunner );
254 		}
255 
256 		@Override
257 		public void onMockRunnerStop( MockRunner mockRunner )
258 		{
259 			runningMockServices.remove( mockRunner );
260 			notifyMockServiceStopped( mockRunner );
261 		}
262 	}
263 
264 	private class InternalLoadTestRunListener extends LoadTestRunListenerAdapter
265 	{
266 		public void afterLoadTest( LoadTestRunner testRunner, LoadTestRunContext context )
267 		{
268 			runningLoadTests.remove( testRunner );
269 			notifyLoadTestFinished( testRunner );
270 		}
271 
272 		public void beforeLoadTest( LoadTestRunner testRunner, LoadTestRunContext context )
273 		{
274 			runningLoadTests.add( testRunner );
275 			notifyLoadTestStarted( testRunner );
276 		}
277 	}
278 
279 	public LoadTestRunner[] getRunningLoadTest()
280 	{
281 		return runningLoadTests.toArray( new LoadTestRunner[runningLoadTests.size()] );
282 	}
283 
284 	public boolean hasRunningTest( TestCase testCase )
285 	{
286 		return hasRunningLoadTest( testCase ) || hasRunningTestCase( testCase );
287 	}
288 
289 	public void init( Workspace workspace )
290 	{
291 		for( int c = 0; c < workspace.getProjectCount(); c++ )
292 		{
293 			Project project = workspace.getProjectAt( c );
294 			monitorProject( project );
295 		}
296 
297 		workspace.addWorkspaceListener( workspaceListener );
298 	}
299 
300 	public void monitorProject( Project project )
301 	{
302 		project.addProjectListener( projectListener );
303 
304 		for( int i = 0; i < project.getTestSuiteCount(); i++ )
305 		{
306 			monitorTestSuite( project.getTestSuiteAt( i ) );
307 		}
308 
309 		for( int i = 0; i < project.getMockServiceCount(); i++ )
310 		{
311 			monitorMockService( project.getMockServiceAt( i ) );
312 		}
313 	}
314 
315 	private void monitorMockService( MockService mockService )
316 	{
317 		mockService.addMockRunListener( mockRunListener );
318 	}
319 
320 	private void monitorTestSuite( TestSuite testSuite )
321 	{
322 		testSuite.addTestSuiteListener( testSuiteListener );
323 
324 		for( int j = 0; j < testSuite.getTestCaseCount(); j++ )
325 		{
326 			monitorTestCase( testSuite.getTestCaseAt( j ) );
327 		}
328 	}
329 
330 	private void monitorTestCase( TestCase testCase )
331 	{
332 		testCase.addTestRunListener( testRunListener );
333 
334 		for( int v = 0; v < testCase.getLoadTestCount(); v++ )
335 		{
336 			testCase.getLoadTestAt( v ).addLoadTestRunListener( loadTestRunListener );
337 		}
338 	}
339 
340 	private void monitorLoadTest( LoadTest loadTest )
341 	{
342 		loadTest.addLoadTestRunListener( loadTestRunListener );
343 	}
344 
345 	public void unmonitorProject( Project project )
346 	{
347 		project.removeProjectListener( projectListener );
348 
349 		for( int c = 0; c < project.getTestSuiteCount(); c++ )
350 		{
351 			TestSuite testSuite = project.getTestSuiteAt( c );
352 			unmonitorTestSuite( testSuite );
353 		}
354 
355 		for( int c = 0; c < project.getMockServiceCount(); c++ )
356 		{
357 			unmonitorMockService( project.getMockServiceAt( c ) );
358 		}
359 	}
360 
361 	private void unmonitorMockService( MockService mockService )
362 	{
363 		mockService.removeMockRunListener( mockRunListener );
364 	}
365 
366 	private void unmonitorTestSuite( TestSuite testSuite )
367 	{
368 		testSuite.removeTestSuiteListener( testSuiteListener );
369 
370 		for( int j = 0; j < testSuite.getTestCaseCount(); j++ )
371 		{
372 			TestCase testCase = testSuite.getTestCaseAt( j );
373 			unmonitorTestCase( testCase );
374 		}
375 	}
376 
377 	private void unmonitorTestCase( TestCase testCase )
378 	{
379 		testCase.removeTestRunListener( testRunListener );
380 
381 		for( int c = 0; c < testCase.getLoadTestCount(); c++ )
382 		{
383 			unmonitorLoadTest( testCase.getLoadTestAt( c ) );
384 		}
385 	}
386 
387 	private void unmonitorLoadTest( LoadTest loadTest )
388 	{
389 		loadTest.removeLoadTestRunListener( loadTestRunListener );
390 	}
391 
392 	public boolean hasRunningTests()
393 	{
394 		return runningLoadTests.size() + runningTestCases.size() > 0;
395 	}
396 
397 	public boolean hasRunningMock( MockService mockService )
398 	{
399 		for( MockRunner runner : runningMockServices )
400 			if( runner.getMockService() == mockService )
401 				return true;
402 
403 		return false;
404 	}
405 
406 	public boolean hasRunningTests( WsdlProject project )
407 	{
408 		for( TestRunner testRunner : runningTestCases )
409 		{
410 			if( testRunner.getTestCase().getTestSuite().getProject() == project )
411 				return true;
412 		}
413 
414 		for( LoadTestRunner loadTestRunner : runningLoadTests )
415 		{
416 			if( loadTestRunner.getLoadTest().getTestCase().getTestSuite().getProject() == project )
417 				return true;
418 		}
419 
420 		// for( MockRunner mockRunner : runningMockServices )
421 		// {
422 		// if( mockRunner.getMockService().getProject() == project )
423 		// return true;
424 		// }
425 
426 		return false;
427 	}
428 
429 	public void cancelAllTests( String reason )
430 	{
431 		for( TestRunner testRunner : runningTestCases )
432 		{
433 			testRunner.cancel( reason );
434 		}
435 
436 		for( LoadTestRunner loadTestRunner : runningLoadTests )
437 		{
438 			loadTestRunner.cancel( reason );
439 		}
440 
441 		for( MockRunner mockRunner : runningMockServices )
442 		{
443 			mockRunner.stop();
444 		}
445 	}
446 }