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	package dk.thoerup.circuitbreaker;
2
3	import java.io.IOException;
4
5	import org.junit.*;
6	import static org.junit.Assert.*;
7
8	import dk.thoerup.circuitbreaker.AccountingCircuitBreaker;
9
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	}