Clover Coverage Report - Pebble 2.5-SNAPSHOT
Coverage timestamp: Sat Jun 12 2010 09:39:29 EST
Overview   Package   File
    FRAMES   NO FRAMES     
197   500   69   2,86
0   360   0,35   69
69     1  
1    
This report was generated with an evaluation server license. Purchase Clover or configure your license.
 
  BlogServiceTest       Line # 17 197 0% 69 78 70,7% 0.7067669
 
  (26)
 
1    package net.sourceforge.pebble.domain;
2   
3    import net.sourceforge.pebble.api.event.comment.CommentListener;
4    import net.sourceforge.pebble.api.event.comment.CommentEvent;
5    import net.sourceforge.pebble.api.event.trackback.TrackBackListener;
6    import net.sourceforge.pebble.api.event.trackback.TrackBackEvent;
7    import net.sourceforge.pebble.api.event.blogentry.BlogEntryEvent;
8    import net.sourceforge.pebble.api.event.blogentry.BlogEntryListener;
9   
10    import java.util.*;
11   
12    /**
13    * Tests for the BlogService class.
14    *
15    * @author Simon Brown
16    */
 
17    public class BlogServiceTest extends SingleBlogTestCase {
18   
19    private BlogService service;
20    private BlogEntry blogEntry;
21   
 
22  26 toggle protected void setUp() throws Exception {
23  26 super.setUp();
24   
25  26 service = new BlogService();
26  26 blogEntry = new BlogEntry(blog);
27  26 blogEntry.setTitle("A title");
28  26 blogEntry.setBody("Some body");
29  26 blogEntry.setExcerpt("Some excerpt");
30  26 blogEntry.setAuthor("An author");
31  26 blogEntry.setDate(new Date());
32    }
33   
34    /**
35    * Tests that listeners are fired when a comment is added.
36    */
 
37  2 toggle public void testListenersFiredWhenCommentAdded() throws Exception {
38  2 final StringBuffer buf = new StringBuffer("123");
39  2 final Comment comment = blogEntry.createComment("title", "body", "author", "email", "website", "127.0.0.1");
40   
41  2 CommentListener listener = new CommentListener() {
 
42  2 toggle public void commentAdded(CommentEvent event) {
43  2 assertEquals(comment, event.getSource());
44  2 buf.reverse();
45    }
46   
 
47  0 toggle public void commentRemoved(CommentEvent event) {
48  0 fail();
49    }
50   
 
51  0 toggle public void commentApproved(CommentEvent event) {
52  0 fail();
53    }
54   
 
55  0 toggle public void commentRejected(CommentEvent event) {
56  0 fail();
57    }
58    };
59   
60  2 blog.getEventListenerList().addCommentListener(listener);
61  2 service.putBlogEntry(blogEntry);
62  2 blogEntry.addComment(comment);
63  2 service.putBlogEntry(blogEntry);
64  2 assertEquals("321", buf.toString());
65    }
66   
67    /**
68    * Tests that listeners are fired when a comment is removed.
69    */
 
70  2 toggle public void testListenersFiredWhenCommentRemoved() throws Exception {
71  2 final StringBuffer buf = new StringBuffer("123");
72  2 final Comment comment = blogEntry.createComment("title", "body", "author", "email", "website", "127.0.0.1");
73  2 blogEntry.addComment(comment);
74  2 service.putBlogEntry(blogEntry);
75   
76  2 CommentListener listener = new CommentListener() {
 
77  0 toggle public void commentAdded(CommentEvent event) {
78  0 fail();
79    }
80   
 
81  2 toggle public void commentRemoved(CommentEvent event) {
82  2 assertEquals(comment, event.getSource());
83  2 buf.reverse();
84    }
85   
 
86  0 toggle public void commentApproved(CommentEvent event) {
87  0 fail();
88    }
89   
 
90  0 toggle public void commentRejected(CommentEvent event) {
91  0 fail();
92    }
93    };
94   
95  2 blog.getEventListenerList().addCommentListener(listener);
96  2 blogEntry.removeComment(comment.getId());
97  2 service.putBlogEntry(blogEntry);
98  2 assertEquals("321", buf.toString());
99    }
100   
101    /**
102    * Tests that listeners are fired when a comment is approved.
103    */
 
104  2 toggle public void testListenersFiredWhenCommentApproved() throws Exception {
105  2 final StringBuffer buf = new StringBuffer("123");
106  2 final Comment comment = blogEntry.createComment("title", "body", "author", "email", "website", "127.0.0.1");
107   
108  2 blogEntry.addComment(comment);
109  2 comment.setPending();
110  2 service.putBlogEntry(blogEntry);
111   
112  2 CommentListener listener = new CommentListener() {
 
113  0 toggle public void commentAdded(CommentEvent event) {
114  0 fail();
115    }
116   
 
117  0 toggle public void commentRemoved(CommentEvent event) {
118  0 fail();
119    }
120   
 
121  2 toggle public void commentApproved(CommentEvent event) {
122  2 assertEquals(comment, event.getSource());
123  2 buf.reverse();
124    }
125   
 
126  0 toggle public void commentRejected(CommentEvent event) {
127  0 fail();
128    }
129    };
130   
131  2 blog.getEventListenerList().addCommentListener(listener);
132  2 comment.setApproved();
133  2 service.putBlogEntry(blogEntry);
134  2 assertEquals("321", buf.toString());
135    }
136   
137    /**
138    * Tests that listeners are fired when a comment is rejected.
139    */
 
140  2 toggle public void testListenersFiredWhenCommentRejected() throws Exception {
141  2 final StringBuffer buf = new StringBuffer("123");
142  2 final Comment comment = blogEntry.createComment("title", "body", "author", "email", "website", "127.0.0.1");
143  2 blogEntry.addComment(comment);
144  2 comment.setPending();
145  2 service.putBlogEntry(blogEntry);
146   
147  2 CommentListener listener = new CommentListener() {
 
148  0 toggle public void commentAdded(CommentEvent event) {
149    }
150   
 
151  0 toggle public void commentRemoved(CommentEvent event) {
152    }
153   
 
154  0 toggle public void commentApproved(CommentEvent event) {
155    }
156   
 
157  2 toggle public void commentRejected(CommentEvent event) {
158  2 assertEquals(comment, event.getSource());
159  2 buf.reverse();
160    }
161    };
162   
163  2 blog.getEventListenerList().addCommentListener(listener);
164  2 comment.setRejected();
165  2 service.putBlogEntry(blogEntry);
166  2 assertEquals("321", buf.toString());
167    }
168   
169    /**
170    * Tests that listeners are fired when a TrackBack is added.
171    */
 
172  2 toggle public void testListenersFiredWhenTrackBackAdded() throws Exception {
173  2 final StringBuffer buf = new StringBuffer("123");
174  2 final TrackBack trackBack = blogEntry.createTrackBack("title", "excerpt", "url", "blogName", "127.0.0.1");
175   
176  2 TrackBackListener listener = new TrackBackListener() {
 
177  2 toggle public void trackBackAdded(TrackBackEvent event) {
178  2 assertEquals(trackBack, event.getSource());
179  2 buf.reverse();
180    }
181   
 
182  0 toggle public void trackBackRemoved(TrackBackEvent event) {
183  0 fail();
184    }
185   
 
186  0 toggle public void trackBackApproved(TrackBackEvent event) {
187  0 fail();
188    }
189   
 
190  0 toggle public void trackBackRejected(TrackBackEvent event) {
191  0 fail();
192    }
193    };
194   
195  2 blog.getEventListenerList().addTrackBackListener(listener);
196  2 service.putBlogEntry(blogEntry);
197  2 blogEntry.addTrackBack(trackBack);
198  2 service.putBlogEntry(blogEntry);
199  2 assertEquals("321", buf.toString());
200    }
201   
202    /**
203    * Tests that listeners are fired when a TrackBack is removed.
204    */
 
205  2 toggle public void testListenersFiredWhenTrackBackRemoved() throws Exception {
206  2 final StringBuffer buf = new StringBuffer("123");
207  2 final TrackBack trackBack = blogEntry.createTrackBack("title", "excerpt", "url", "blogName", "127.0.0.1");
208  2 blogEntry.addTrackBack(trackBack);
209  2 service.putBlogEntry(blogEntry);
210   
211  2 TrackBackListener listener = new TrackBackListener() {
 
212  0 toggle public void trackBackAdded(TrackBackEvent event) {
213  0 fail();
214    }
215   
 
216  2 toggle public void trackBackRemoved(TrackBackEvent event) {
217  2 assertEquals(trackBack, event.getSource());
218  2 buf.reverse();
219    }
220   
 
221  0 toggle public void trackBackApproved(TrackBackEvent event) {
222  0 fail();
223    }
224   
 
225  0 toggle public void trackBackRejected(TrackBackEvent event) {
226  0 fail();
227    }
228    };
229   
230  2 blog.getEventListenerList().addTrackBackListener(listener);
231  2 blogEntry.removeTrackBack(trackBack.getId());
232  2 service.putBlogEntry(blogEntry);
233  2 assertEquals("321", buf.toString());
234    }
235   
236    /**
237    * Tests that listeners are fired when a TrackBack is approved.
238    */
 
239  2 toggle public void testListenersFiredWhenTrackBackApproved() throws Exception {
240  2 final StringBuffer buf = new StringBuffer("123");
241  2 final TrackBack trackBack = blogEntry.createTrackBack("title", "excerpt", "url", "blogName", "127.0.0.1");
242  2 blogEntry.addTrackBack(trackBack);
243  2 trackBack.setPending();
244  2 service.putBlogEntry(blogEntry);
245   
246  2 TrackBackListener listener = new TrackBackListener() {
 
247  0 toggle public void trackBackAdded(TrackBackEvent event) {
248  0 fail();
249    }
250   
 
251  0 toggle public void trackBackRemoved(TrackBackEvent event) {
252  0 fail();
253    }
254   
 
255  2 toggle public void trackBackApproved(TrackBackEvent event) {
256  2 assertEquals(trackBack, event.getSource());
257  2 buf.reverse();
258    }
259   
 
260  0 toggle public void trackBackRejected(TrackBackEvent event) {
261  0 fail();
262    }
263    };
264   
265  2 blog.getEventListenerList().addTrackBackListener(listener);
266  2 trackBack.setApproved();
267  2 service.putBlogEntry(blogEntry);
268  2 assertEquals("321", buf.toString());
269    }
270   
271    /**
272    * Tests that listeners are fired when a TrackBack is rejected.
273    */
 
274  2 toggle public void testListenersFiredWhenTrackBackRejected() throws Exception {
275  2 final StringBuffer buf = new StringBuffer("123");
276  2 final TrackBack trackBack = blogEntry.createTrackBack("title", "excerpt", "url", "blogName", "127.0.0.1");
277  2 blogEntry.addTrackBack(trackBack);
278  2 trackBack.setPending();
279  2 service.putBlogEntry(blogEntry);
280   
281  2 TrackBackListener listener = new TrackBackListener() {
 
282  0 toggle public void trackBackAdded(TrackBackEvent event) {
283    }
284   
 
285  0 toggle public void trackBackRemoved(TrackBackEvent event) {
286    }
287   
 
288  0 toggle public void trackBackApproved(TrackBackEvent event) {
289    }
290   
 
291  2 toggle public void trackBackRejected(TrackBackEvent event) {
292  2 assertEquals(trackBack, event.getSource());
293  2 buf.reverse();
294    }
295    };
296   
297  2 blog.getEventListenerList().addTrackBackListener(listener);
298  2 trackBack.setRejected();
299  2 service.putBlogEntry(blogEntry);
300  2 assertEquals("321", buf.toString());
301    }
302   
303    /**
304    * Tests that listeners are fired when a blog entry is published.
305    */
 
306  2 toggle public void testListenersFiredWhenBlogEntryPublished() throws Exception {
307  2 final StringBuffer buf = new StringBuffer("123");
308  2 blogEntry.setPublished(false);
309  2 service.putBlogEntry(blogEntry);
310   
311  2 BlogEntryListener listener = new BlogEntryListener() {
 
312  0 toggle public void blogEntryAdded(BlogEntryEvent event) {
313  0 fail();
314    }
315   
 
316  0 toggle public void blogEntryRemoved(BlogEntryEvent event) {
317  0 fail();
318    }
319   
 
320  0 toggle public void blogEntryChanged(BlogEntryEvent event) {
321  0 fail();
322    }
323   
 
324  2 toggle public void blogEntryPublished(BlogEntryEvent event) {
325  2 assertEquals(blogEntry, event.getSource());
326  2 buf.reverse();
327    }
328   
 
329  0 toggle public void blogEntryUnpublished(BlogEntryEvent event) {
330  0 fail();
331    }
332    };
333   
334  2 blog.getEventListenerList().addBlogEntryListener(listener);
335  2 blogEntry.setPublished(true);
336  2 service.putBlogEntry(blogEntry);
337  2 assertEquals("321", buf.toString());
338    }
339   
340    /**
341    * Tests that listeners are fired when a blog entry is unpublished.
342    */
 
343  2 toggle public void testListenersFiredWhenBlogEntryUnpublished() throws Exception {
344  2 final StringBuffer buf = new StringBuffer("123");
345  2 blogEntry.setPublished(true);
346  2 service.putBlogEntry(blogEntry);
347   
348  2 BlogEntryListener listener = new BlogEntryListener() {
 
349  0 toggle public void blogEntryAdded(BlogEntryEvent event) {
350  0 fail();
351    }
352   
 
353  0 toggle public void blogEntryRemoved(BlogEntryEvent event) {
354  0 fail();
355    }
356   
 
357  0 toggle public void blogEntryChanged(BlogEntryEvent event) {
358  0 fail();
359    }
360   
 
361  0 toggle public void blogEntryPublished(BlogEntryEvent event) {
362  0 fail();
363    }
364   
 
365  2 toggle public void blogEntryUnpublished(BlogEntryEvent event) {
366  2 assertEquals(blogEntry, event.getSource());
367  2 buf.reverse();
368    }
369    };
370   
371  2 blog.getEventListenerList().addBlogEntryListener(listener);
372  2 blogEntry.setPublished(false);
373  2 service.putBlogEntry(blogEntry);
374  2 assertEquals("321", buf.toString());
375    }
376   
377    /**
378    * Tests that listeners are fired when a blog entry is changed.
379    */
 
380  2 toggle public void testListenersFiredWhenBlogEntryChanged() throws Exception {
381  2 BlogService service = new BlogService();
382  2 service.putBlogEntry(blogEntry);
383   
384  2 final StringBuffer buf = new StringBuffer("123");
385   
386  2 BlogEntryListener listener = new BlogEntryListener() {
 
387  0 toggle public void blogEntryAdded(BlogEntryEvent event) {
388  0 fail();
389    }
390   
 
391  0 toggle public void blogEntryRemoved(BlogEntryEvent event) {
392  0 fail();
393    }
394   
 
395  2 toggle public void blogEntryChanged(BlogEntryEvent event) {
396  2 assertEquals(blogEntry, event.getSource());
397  2 assertNotNull(event.getPropertyChangeEvents());
398  2 buf.reverse();
399    }
400   
 
401  0 toggle public void blogEntryPublished(BlogEntryEvent event) {
402  0 fail();
403    }
404   
 
405  0 toggle public void blogEntryUnpublished(BlogEntryEvent event) {
406  0 fail();
407    }
408    };
409   
410  2 blog.getEventListenerList().addBlogEntryListener(listener);
411  2 blogEntry.setTitle("A new title");
412  2 service.putBlogEntry(blogEntry);
413  2 assertEquals("321", buf.toString());
414    }
415   
416    /**
417    * Tests that comment listeners are fired when a blog entry is removed.
418    */
 
419  2 toggle public void testListenersFiredForCommentsWhenBlogEntryRemoved() throws Exception {
420  2 final Comment comment1 = blogEntry.createComment("title", "body", "author", "email", "website", "127.0.0.1");
421  2 final Comment comment2 = blogEntry.createComment("title", "body", "author", "email", "website", "127.0.0.1");
422  2 final Comment comment3 = blogEntry.createComment("title", "body", "author", "email", "website", "127.0.0.1");
423   
424  2 blogEntry.addComment(comment1);
425  2 blogEntry.addComment(comment2);
426  2 service.putBlogEntry(blogEntry);
427   
428  2 comment3.setParent(comment2);
429  2 blogEntry.addComment(comment3);
430  2 service.putBlogEntry(blogEntry);
431   
432  2 final List comments = new ArrayList();
433   
434  2 CommentListener listener = new CommentListener() {
 
435  0 toggle public void commentAdded(CommentEvent event) {
436  0 fail();
437    }
438   
 
439  6 toggle public void commentRemoved(CommentEvent event) {
440  6 comments.add(event.getSource());
441    }
442   
 
443  0 toggle public void commentApproved(CommentEvent event) {
444  0 fail();
445    }
446   
 
447  0 toggle public void commentRejected(CommentEvent event) {
448  0 fail();
449    }
450    };
451   
452  2 blog.getEventListenerList().addCommentListener(listener);
453  2 service.removeBlogEntry(blogEntry);
454   
455  2 assertEquals(comment1, comments.get(0));
456  2 assertEquals(comment2, comments.get(1));
457  2 assertEquals(comment3, comments.get(2));
458    }
459   
460    /**
461    * Tests that TrackBack listeners are fired when a blog entry is removed.
462    */
 
463  2 toggle public void testListenersFiredForTrackBacksWhenBlogEntryRemoved() throws Exception {
464  2 final TrackBack trackBack1 = blogEntry.createTrackBack("title", "excerpt", "url", "blogName", "127.0.0.1");
465  2 final TrackBack trackBack2 = blogEntry.createTrackBack("title", "excerpt", "url", "blogName", "127.0.0.1");
466  2 final TrackBack trackBack3 = blogEntry.createTrackBack("title", "excerpt", "url", "blogName", "127.0.0.1");
467   
468  2 blogEntry.addTrackBack(trackBack1);
469  2 blogEntry.addTrackBack(trackBack2);
470  2 blogEntry.addTrackBack(trackBack3);
471  2 service.putBlogEntry(blogEntry);
472   
473  2 final List trackBacks = new ArrayList();
474   
475  2 TrackBackListener listener = new TrackBackListener() {
 
476  0 toggle public void trackBackAdded(TrackBackEvent event) {
477  0 fail();
478    }
479   
 
480  6 toggle public void trackBackRemoved(TrackBackEvent event) {
481  6 trackBacks.add(event.getSource());
482    }
483   
 
484  0 toggle public void trackBackApproved(TrackBackEvent event) {
485  0 fail();
486    }
487   
 
488  0 toggle public void trackBackRejected(TrackBackEvent event) {
489  0 fail();
490    }
491    };
492   
493  2 blog.getEventListenerList().addTrackBackListener(listener);
494  2 service.removeBlogEntry(blogEntry);
495   
496  2 assertEquals(trackBack1, trackBacks.get(0));
497  2 assertEquals(trackBack2, trackBacks.get(1));
498  2 assertEquals(trackBack3, trackBacks.get(2));
499    }
500    }
 
CloverReport generated by Clover Code Coverage v3.0.2
Sat Jun 12 2010 09:39:50 EST.		   Clover Evaluation License registered to Clover Maven Plugin. You have 20 day(s) before your license expires.