thoerup/circuitbreaker/TestAccountingCircuitBreaker.java

package dk.thoerup.circuitbreaker;

import java.io.IOException;

import org.junit.*;
import static org.junit.Assert.*;

import dk.thoerup.circuitbreaker.AccountingCircuitBreaker;

public class TestAccountingCircuitBreaker {
        public static final int DELAY = 50;
        public static final int THRESHOLD = 2;
        
        
        AccountingCircuitBreaker acb;
        
        @Before public void setup() {
                acb = new AccountingCircuitBreaker("test", THRESHOLD, DELAY);
        }
        
        @Test public void initialValues() {
                assertTrue(acb.getBlockCount() == 0);
                assertTrue(acb.getTotalCallCount() == 0);
                assertTrue(acb.getTotalFailureCount() == 0);
                assertTrue(acb.getTripCount() == 0 );
        }
        
        @Test public void callCounter() throws Exception{
                acb.invoke( new SucceedingInvocation() );
                assertTrue( acb.getTotalCallCount() == 1);
                
                acb.invoke( new SucceedingInvocation() );
                assertTrue( acb.getTotalCallCount() == 2);              
        }
        
        @Test public void testFailing() throws Exception{
                try{
                        acb.invoke( new FailingInvocation() );
                } catch (IOException e) {}
                
                assertTrue( acb.getTotalFailureCount() == 1);
                
                try{
                        acb.invoke( new FailingInvocation() );
                } catch (IOException e) {}
                
                assertTrue( acb.getTripCount() == 1 );
                assertTrue( acb.getTotalCallCount() == 2 );
                assertTrue( acb.getTotalFailureCount() == 2);
        }
        
        @Test public void testBlockCounter() {
                assertTrue( acb.getBlockCount() == 0);
                
                acb.tripBreaker();
                try {
                        acb.invoke(new SucceedingInvocation() );
                } catch (Exception e) {}
                
                assertTrue( acb.getBlockCount() == 1);
                
                
        }
}
1	torben	463	package dk.thoerup.circuitbreaker;
2
3			import java.io.IOException;
4
5			import org.junit.*;
6			import static org.junit.Assert.*;
7
8	torben	467	import dk.thoerup.circuitbreaker.AccountingCircuitBreaker;
9	torben	463
10			public class TestAccountingCircuitBreaker {
11			public static final int DELAY = 50;
12			public static final int THRESHOLD = 2;
13
14
15			AccountingCircuitBreaker acb;
16
17			@Before public void setup() {
18			acb = new AccountingCircuitBreaker("test", THRESHOLD, DELAY);
19			}
20
21			@Test public void initialValues() {
22			assertTrue(acb.getBlockCount() == 0);
23			assertTrue(acb.getTotalCallCount() == 0);
24			assertTrue(acb.getTotalFailureCount() == 0);
25			assertTrue(acb.getTripCount() == 0 );
26			}
27
28			@Test public void callCounter() throws Exception{
29			acb.invoke( new SucceedingInvocation() );
30			assertTrue( acb.getTotalCallCount() == 1);
31
32			acb.invoke( new SucceedingInvocation() );
33			assertTrue( acb.getTotalCallCount() == 2);
34			}
35
36			@Test public void testFailing() throws Exception{
37			try{
38			acb.invoke( new FailingInvocation() );
39			} catch (IOException e) {}
40
41			assertTrue( acb.getTotalFailureCount() == 1);
42
43			try{
44			acb.invoke( new FailingInvocation() );
45			} catch (IOException e) {}
46
47			assertTrue( acb.getTripCount() == 1 );
48			assertTrue( acb.getTotalCallCount() == 2 );
49			assertTrue( acb.getTotalFailureCount() == 2);
50			}
51
52			@Test public void testBlockCounter() {
53			assertTrue( acb.getBlockCount() == 0);
54
55			acb.tripBreaker();
56			try {
57			acb.invoke(new SucceedingInvocation() );
58			} catch (Exception e) {}
59
60			assertTrue( acb.getBlockCount() == 1);
61
62
63			}
64			}