import static org.junit.Assert.assertEquals;

import java.util.*;
import java.util.concurrent.*;

import org.junit.Test;
import org.slf4j.*;

import com.netflix.hystrix.*;

public class SimpleHystrixCommandTest {
    private static final Logger logger = LoggerFactory.getLogger(SimpleHystrixCommandTest.class);

    @Test
    public void testSimpleHystrixCommand() throws Exception {
        int executionCounter = 0;
        int successCounter = 0;
        int fallbackCounter = 0;
        int nullCounter = 0;

        final int executorThreadPoolSize = 10;
        final int executionCount = 500000;
        ExecutorService executor = null;
        try {
            executor = Executors.newFixedThreadPool(executorThreadPoolSize);

            final List<Future<Boolean>> futures = new ArrayList<Future<Boolean>>();
            for (int i = 1; i <= executionCount; i++) {
                final int c = i;
                futures.add(executor.submit(new Callable<Boolean>() {

                    @Override
                    public Boolean call() throws Exception {
                        SimpleHystrixCommand cmd = new SimpleHystrixCommand(Boolean.TRUE);
                        Boolean b = cmd.execute();
                        if (b == null) {
                            System.err.println(c + " NULL events: " + cmd.getExecutionEvents() + " " + cmd.getExecutionTimeInMilliseconds());
                        }
                        return b;
                    }

                }));
            }
            for (final Future<Boolean> future : futures) {
                final Boolean response = future.get();
                executionCounter++;
                if (response == null) {
                    System.err.println("Null Response received on Execution=[" + executionCounter + "]");
                    nullCounter++;
                } else {
                    if (response) {
                        successCounter++;
                    } else {
                        fallbackCounter++;
                    }
                }
            }
        } finally {
            if (executor != null) {
                executor.shutdown();
            }
        }
        System.err.println("Success Count= " + successCounter);
        System.err.println("Fallback Count= " + fallbackCounter);
        System.err.println("Null Count= " + nullCounter);
        assertEquals(0, nullCounter);
    }

    private static class SimpleHystrixCommand extends HystrixCommand<Boolean> {
        private final Boolean response;

        public SimpleHystrixCommand(final Boolean response) {
            super(HystrixCommandGroupKey.Factory.asKey("SimpleHystrixCommand"));
            this.response = response;
        }

        @Override
        protected Boolean run() throws Exception {
            return response;
        }

        @Override
        protected Boolean getFallback() {
            return Boolean.FALSE;
        }
    }
}