thoerup/circuitbreaker/TestAccountingCircuitBreaker.java

package dk.thoerup.circuitbreaker;

import static org.junit.Assert.assertTrue;

import java.io.IOException;

import org.junit.Before;
import org.junit.Test;

import dk.thoerup.circuitbreaker.config.StaticConfig;

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