KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > webman > stager > test > StagerTest


1 /*
2  * StagerTest.java
3  *
4  * Created on 22. Mai 2001, 17:26
5  */

6
7 package webman.stager.test;
8
9 import java.io.*;
10 import java.net.*;
11 import java.util.*;
12 import org.apache.log4j.*;
13 import webman.stager.PropertySet;
14 import webman.stager.PropertyNotFoundException;
15 //import webman.stager.Stager;
16

17 /**
18  *
19  * @author $Author: torsten $
20  * @version $Revision: 1.15 $
21  */

22 public class StagerTest extends junit.framework.TestCase
23 {
24     final static String JavaDoc NEWLINE = System.getProperty("line.separator");
25     final static String JavaDoc FS = System.getProperty("file.separator");
26     final static String JavaDoc PROPERTY_FILE = "StagerTest.properties";
27     private static Category CAT = Category.getInstance(StagerTest.class);
28
29     private String JavaDoc CLEANUP_CGI, TEST_CGI, STAGER_URL, USERNAME, PASSWORD, CLEANUP_SUCCESS_MESSAGE, TEST_SUCCESS_MESSAGE, output;
30     private Vector targets, errorLog;
31
32     private boolean cancelTest = false;
33     private int TIME_OUT;
34  
35         
36     static
37     {
38         URL url = StagerTest.class.getResource("StagerTest_log4j.properties");
39         PropertyConfigurator.configure(url);
40     }
41     
42     /** Creates new StagerTest */
43     public StagerTest(String JavaDoc name)
44     {
45         super(name);
46     }
47
48     public String JavaDoc getProperty(PropertySet source, String JavaDoc key) throws PropertyNotFoundException
49     {
50         String JavaDoc result = source.get(key);
51         if ( result == null )
52         {
53             throw new PropertyNotFoundException(key);
54         }
55         else
56         {
57             return result;
58         }
59     }
60     
61     private void warn(String JavaDoc msg)
62     {
63         CAT.warn(msg);
64         CAT.warn("Dieses Testziel wird im Weiteren nicht mehr berücksichtigt.");
65     }
66         
67     protected void runTest() throws java.lang.Throwable JavaDoc
68     {
69         testStager();
70     }
71     
72     protected void setUp() throws Exception JavaDoc
73     {
74         //erstmal die Konfiguration lesen
75
CAT.info("Lese Testkonfiguration...");
76         Properties p = new Properties();
77         try
78         {
79             //p.load(Stager.getResourceInputStream(StagerTest.class,PROPERTY_FILE));
80
p.load(StagerTest.class.getResourceAsStream(PROPERTY_FILE));
81         }
82         catch ( Exception JavaDoc e )
83         {
84             fail("Konnte Testkonfiguration nicht lesen: " + e);
85         }
86         PropertySet all = new PropertySet(p);
87         targets = all.getPropertyGroup("Target");
88         if ( targets.size() == 0 )
89         {
90             fail("Die Testkonfiguration ist fehlerhaft: Keine Zielrechner definiert.");
91         }
92         else
93         {
94             int i = 0;
95             while ( i < targets.size() )
96             {
97                 String JavaDoc target = (String JavaDoc)targets.elementAt(i);
98                 CAT.debug("Konfiguration: Lese Target" + i + " (" + target + ").");
99                 if ( target.toLowerCase().startsWith("file:/") )
100                 {
101                     PropertySet temp = parseFile(target.substring(6));
102                     if ( temp != null ) //wenn eine gültige Teil-Testkonfiguration vorliegt
103
{
104                         targets.setElementAt(temp,i);
105                     }
106                     else
107                     {//der Konfigdatei-Descriptor muss eh raus
108
targets.removeElementAt(i--);
109                     //i--, damit verhältnis i<targets.size wieder stimmt (targets.size wird ja auch kleiner)!
110
}
111                 }
112                 else
113                 {
114                     targets.setElementAt(checkFormat(target),i);
115                 }
116                 i++;
117             }
118         }
119         try
120         {
121             CLEANUP_CGI = getProperty(all,"CleanUp-cgi");
122             if ( CLEANUP_CGI.startsWith("/") )
123             {
124                CLEANUP_CGI = CLEANUP_CGI.substring(1);
125             }
126             TEST_CGI = getProperty(all,"Test-cgi");
127             if ( TEST_CGI.startsWith("/") )
128             {
129                TEST_CGI = TEST_CGI.substring(1);
130             }
131             STAGER_URL = getProperty(all,"StagerURL");
132             if ( !STAGER_URL.toLowerCase().startsWith("http://") )
133             {
134                 STAGER_URL = "http://" + STAGER_URL;
135             }
136             USERNAME = all.get("UserName");
137             PASSWORD = all.get("PassWord");
138             CLEANUP_SUCCESS_MESSAGE = getProperty(all,"CleanupSuccess");
139             TEST_SUCCESS_MESSAGE = getProperty(all,"TestSuccess");
140             TIME_OUT = Integer.parseInt(getProperty(all,"TimeOut"));
141         }
142         catch ( Exception JavaDoc e )
143         {
144             fail("Die Testkonfiguration ist fehlerhaft: " + e);
145         }
146         //-----------------------------------
147
//
148
// jetzt gehts richtig los
149
//
150
//------------------------------------
151
if ( targets.size() == 0 ) //wenn alle Ziele ungültig waren...
152
{
153             CAT.info("Keine gültige Konfiguration gefunden - es gibt nichts mehr zu stagen. :(");
154             cancelTest = true;
155             return;
156         }
157         //erstmal alle cleanen. wenn da schon Fehler auftreten, Testziele aus Liste entfernen
158
CAT.info("Bereite Zielverzeichniss(e) vor (Leerung)...");
159         int i = 0;
160         String JavaDoc target=null, username=null, password=null;
161         while ( i < targets.size() )
162         {
163             if ( targets.elementAt(i) instanceof String JavaDoc )
164             {
165                 target = (String JavaDoc)targets.elementAt(i) + CLEANUP_CGI;
166                 CAT.debug("target" + i + " (String)= " + target);
167             }
168             else
169             {
170                 target = ((PropertySet)targets.elementAt(i)).get("TargetHost") + CLEANUP_CGI;
171                 username = ((PropertySet)targets.elementAt(i)).get("TargetCGIUserName");
172                 password = ((PropertySet)targets.elementAt(i)).get("TargetCGIPassword");
173                 CAT.debug("target" + i + " (PropertySet)= " + target);
174             }
175             try
176             {
177                 output = readHTTP(target,username,password);
178                 if ( output.length() == 0 || !output.trim().equals(CLEANUP_SUCCESS_MESSAGE) )
179                 {
180                     warn("setUp(" + target + "): Konnte Zielverzeichnis nicht erfolgreich leeren.");
181                     //das bewusste Target wird aus dem weiteren Testverlauf herausgehalten
182
targets.remove(i);
183                 }
184                 else
185                 {
186                     i++;
187                 }
188             }
189             catch (NoRouteToHostException e)
190             {
191                 warn("setUp(" + target + "): Kann Zielrechner nicht erreichen. Details: " + e);
192                 targets.remove(i);
193             }
194             catch (FileNotFoundException e)
195             {
196                 warn("setUp(" + target + "): Kann Datei nicht finden/aufrufen. Details: " + e);
197                 targets.remove(i);
198             }
199             catch (ConnectException e)
200             {
201                 warn("setUp(" + target + "): Kann Webserver nicht aufrufen. Details: " + e);
202                 targets.remove(i);
203             }
204         }
205         CAT.info("Beginne Stagen...");
206         try
207         {
208             output = readHTTP(STAGER_URL,USERNAME,PASSWORD);
209         }
210         catch (NoRouteToHostException e)
211         {
212             CAT.warn("setUp(" + STAGER_URL + "): Kann stagenden Rechner nicht erreichen. Details: " + e);
213             cancelTest = true;
214         }
215         catch (FileNotFoundException e)
216         {
217             CAT.warn("setUp(" + STAGER_URL + "): Kann Datei nicht finden/aufrufen. Details: " + e);
218             cancelTest = true;
219         }
220         catch (ConnectException e)
221         {
222             CAT.warn("setUp(" + STAGER_URL + "): Kann Staging nicht durchführen (wahrscheinlich läuft Tomcat bzw. der Webserver nicht). Details: " + e);
223             cancelTest = true;
224         }
225         if ( output.toLowerCase().indexOf("finished with errors") > -1 )
226         {
227             CAT.warn("setUp(" + STAGER_URL + "): Beim Stagen sind Fehler aufgetreten. Wahrscheinlich wird dies das Testergebnis negativ beeinflussen.");
228         }
229     }
230     
231     private String JavaDoc checkFormat(String JavaDoc src)
232     {
233         if ( !src.endsWith("/") )
234         {
235             src += "/";
236         }
237         if ( !src.startsWith("http://") )
238         {
239             src = "http://" + src;
240         }
241         return src;
242     }
243     
244     private PropertySet parseFile(String JavaDoc src)
245     {
246         CAT.info("Parse Teilkonfiguration: " + src);
247         Properties p = new Properties();
248         try
249         {
250             InputStream temp = StagerTest.class.getResourceAsStream(src);
251             if ( temp != null )
252             {
253                 p.load(temp);
254             }
255             else
256             {
257                 warn("Konfigurationsdatei " + src + " konnte nicht gefunden werden.");
258                 return null;
259             }
260         }
261         catch ( Exception JavaDoc e )
262         {
263             warn("Konnte Teil-Testkonfiguration nicht lesen: " + e);
264             return null;
265         }
266         PropertySet result = new PropertySet(p);
267         if ( result.get("TargetHost") == null )
268         {
269             warn("Unvollständige Teil-Testkonfiguration (" + src + "): TargetHost nicht spezifiziert.");
270             return null;
271         }
272         result.set("TargetHost",checkFormat(result.get("TargetHost")));
273         if ( result.get("TargetCGIPassword") != null && result.get("TargetCGIUserName") == null
274           || result.get("TargetCGIPassword") == null && result.get("TargetCGIUserName") != null )
275         {
276             warn("Unvollständige Teil-Testkonfiguration (" + src + "): TargetCGIUserName kann nur zusammen mit TargetCGIPassword angegeben werden.");
277             return null;
278         }
279         return result;
280     }
281     
282     public void testStager() throws Exception JavaDoc
283     {
284         if ( cancelTest )
285         {
286             CAT.warn("Im Test sind interne Fehler aufgetreten, "
287             + "die jedoch keine Aussage über das eigentliche Testziel zulassen. "
288             + "Daher wird der Test erstmal als erfolgreich markiert.");
289             assert(true);
290             return;
291         }
292         CAT.info("Beginne Vergleich mit den Referenzverzeichnissen...");
293         errorLog = new Vector(); //hier werden alle Fehler gemerkt
294
String JavaDoc target=null, username=null, password=null;
295         for ( int i=0; i<targets.size(); i++ )
296         {
297             if ( targets.elementAt(i) instanceof String JavaDoc )
298             {
299                 target = (String JavaDoc)targets.elementAt(i) + TEST_CGI;
300             }
301             else
302             {
303                 target = ((PropertySet)targets.elementAt(i)).get("TargetHost") + TEST_CGI;
304                 username = ((PropertySet)targets.elementAt(i)).get("TargetCGIUserName");
305                 password = ((PropertySet)targets.elementAt(i)).get("TargetCGIPassword");
306             }
307             try
308             {
309                 output = readHTTP(target,username,password);
310                 if ( output.length() > 0 )
311                 {
312                     if ( output.trim().equals(TEST_SUCCESS_MESSAGE) )
313                     {
314                         continue;
315                     }
316                     else
317                     {
318                         errorLog.add("target" + i + " (" + target + "): " + output);
319                     }
320                 }
321                 else
322                 {
323                     throw new Exception JavaDoc(target + " lieferte keine Ausgabe zurück.");
324                 }
325             }
326             catch (NoRouteToHostException e)
327             {
328                warn("testStager(" + target + "): Kann Zielrechner nicht erreichen. Details: " + e);
329             }
330             catch (FileNotFoundException e)
331             {
332                 warn("testStager(" + target + "): Kann Datei nicht finden/aufrufen. Details: " + e);
333                 cancelTest = true;
334             }
335         }
336         CAT.info("Beende Test.");
337         String JavaDoc errors = "";
338         for ( int i=0; i<errorLog.size(); i++)
339         {
340             errors += (String JavaDoc)errorLog.elementAt(i) + NEWLINE;
341         }
342         if ( errors.equals("") )
343         {
344             assert(true); //wenn alle durchgelaufen sind, kann man wohl von einem erfolgreichen Test sprechen
345
}
346         else
347         {
348             fail(errors);
349         }
350     }
351     
352     private String JavaDoc readHTTP(String JavaDoc url, String JavaDoc username, String JavaDoc password) throws Exception JavaDoc
353     {
354         HttpURLConnection connection = (HttpURLConnection)((new URL(url)).openConnection());
355         if ( username != null && password != null )
356         {
357             String JavaDoc userPassword = username + ":" + password;
358             String JavaDoc encoding = new sun.misc.BASE64Encoder().encode (userPassword.getBytes());
359             connection.setRequestProperty ("Authorization", "Basic " + encoding);
360         }
361         connection.connect();
362         BufferedReader reader = new BufferedReader(new InputStreamReader(connection.getInputStream()));
363         String JavaDoc str = null, text = "";
364         long startTime = (new Date()).getTime();
365         while ( (new Date()).getTime() - startTime < TIME_OUT && null!=(str=reader.readLine()) )
366         {
367             text += str + NEWLINE;
368             startTime = (new Date()).getTime(); //nach jedem erfolgreichen Lesen Timeout neu abzählen
369
}
370         connection.disconnect();
371         if ( str != null )
372         {//wenn die schleife nicht deswegen verlassen wurde, so muss ein timeout vorgelegen haben
373
throw new Exception JavaDoc("Timeout beim Lesen von " + url + ".");
374         }
375         return text;
376     }
377 }
Popular Tags