View Javadoc

1   /*
2    *  soapUI, copyright (C) 2006 eviware.com 
3    *
4    *  soapUI is free software; you can redistribute it and/or modify it under the 
5    *  terms of the GNU Lesser General Public License as published by the Free Software Foundation; 
6    *  either version 2.1 of the License, or (at your option) any later version.
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.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 }