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 }