Eljam\CircuitBreaker\BreakerTest

Complexity

Total Complexity

13

Size/Duplication

Total Lines	194
Duplicated Lines	18.04 %

Coupling/Cohesion

Components	2
Dependencies	6

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	setUp()	0	4	1
B	testMultiProcess()	0	24	1
A	testGetTheResult()	0	13	1
A	testIgnoreAllException()	18	18	1
A	testThrowCustomException()	17	17	1
A	testOpenBehavior()	0	21	2
B	testHalfOpenBehavior()	0	34	3
B	testAllowedException()	0	28	2
A	tearDown()	0	4	1

<?php

namespace Eljam\CircuitBreaker;

use Doctrine\Common\Cache\FilesystemCache;
use Eljam\CircuitBreaker\Event\CircuitEvent;
use Eljam\CircuitBreaker\Event\CircuitEvents;
use Eljam\CircuitBreaker\Exception\CircuitOpenException;
use Eljam\CircuitBreaker\Exception\CustomException;

/**
 * Class BreakerTest.
 */
class BreakerTest extends \PHPUnit_Framework_TestCase
{
    protected $dir;

    public function setUp()
    {
        $this->dir = sys_get_temp_dir().DIRECTORY_SEPARATOR.'store';
    }

    /**
     * testMultiProcess.
     */
    public function testMultiProcess()
    {
        $fileCache = new FilesystemCache($this->dir, 'txt');
        $breaker = new Breaker('github_api', ['ignore_exceptions' => true], $fileCache);
        $breaker2 = new Breaker('github_api', ['ignore_exceptions' => true], $fileCache);

        $breaker1FailureCount = 0;

        $breaker->addListener(CircuitEvents::FAILURE, function (CircuitEvent $event) use (&$breaker1FailureCount) {
            $breaker1FailureCount = $event->getCircuit()->getFailures();
        });

        $breaker2->addListener(CircuitEvents::FAILURE, function (CircuitEvent $event) use (&$breaker1FailureCount) {
            $this->assertEquals($breaker1FailureCount, $event->getCircuit()->getFailures());
        });

        $fn = function () {
            throw new CustomException("An error as occurred");
        };

        $breaker->protect($fn);

        $breaker2->protect($fn);
    }

    /**
     * testOpenBehavior.
     */
    public function testOpenBehavior()
    {
        $breaker = new Breaker(
            'exception breaker',
            ['exclude_exceptions' => ['Eljam\CircuitBreaker\Exception\CustomException']]
        );

        $breaker->addListener(CircuitEvents::OPEN, function (CircuitEvent $event) {
            $this->assertInstanceOf('Eljam\CircuitBreaker\Circuit', $event->getCircuit());
        });

        $this->setExpectedException('Eljam\CircuitBreaker\Exception\CircuitOpenException');

        $fn = function () {
            throw new CustomException("An error as occurred");
        };

        for ($i = 0; $i <= 5; $i++) {
            $breaker->protect($fn);
        }
    }

    /**
     * testHalfOpenBehavior.
     */
    public function testHalfOpenBehavior()
    {
        $breaker = new Breaker(
            'exception breaker',
            [
                'reset_timeout' => 1,
                'ignore_exceptions' => true,
            ]
        );

        $breaker->addListener(CircuitEvents::HALF_OPEN, function (CircuitEvent $event) {
            $this->assertInstanceOf('Eljam\CircuitBreaker\Circuit', $event->getCircuit());
        });

        $fn = function () {
            throw new CustomException("An error as occurred");
        };

        try {
            for ($i = 0; $i <= 5; $i++) {
                $breaker->protect($fn);
            }
        } catch (CircuitOpenException $e) {
            $this->assertSame('Eljam\CircuitBreaker\Exception\CircuitOpenException', get_class($e));
        }

        sleep(2);

        $fnPass = function () {
            return 'ok';
        };

        $breaker->protect($fnPass);
    }

    /**
     * testGetTheResult.
     */
    public function testGetTheResult()
    {
        $breaker = new Breaker('simple_echo');
        $hello = 'eljam';

        $fn = function () use ($hello) {
            return $hello;
        };

        $result = $breaker->protect($fn);

        $this->assertSame($hello, $result);
    }

    /**
     * testIgnoreException.
     */
    public function testIgnoreAllException()

This method seems to be duplicated in your project.

    {
        $breaker = new Breaker(
            'simple_echo',
            ['ignore_exceptions' => true]
        );
        $hello = 'eljam';

        $fn = function () use ($hello) {
            throw new CustomException("An error as occurred");

            return $hello;

return $hello; does not seem to be reachable.

        };

        $result = $breaker->protect($fn);

        $this->assertNull($result);
    }

    /**
     * testThrowCustomException.
     */
    public function testThrowCustomException()

This method seems to be duplicated in your project.

    {
        $breaker = new Breaker(
            'custom_exception'
        );
        $hello = 'eljam';

        $this->setExpectedException('Eljam\CircuitBreaker\Exception\CustomException');

        $fn = function () use ($hello) {
            throw new CustomException("An error as occurred");

            return $hello;

return $hello; does not seem to be reachable.

        };

        $breaker->protect($fn);
    }

    public function testAllowedException()
    {
        $breaker = new Breaker(
            'allowed_exception',
            [
                'ignore_exceptions' => false,
                'allowed_exceptions' => [
                    'Eljam\CircuitBreaker\Exception\CustomException',
                ],
            ]
        );

        $breaker1FailureCount = 0;
        $breaker->addListener(CircuitEvents::FAILURE, function (CircuitEvent $event) use (&$breaker1FailureCount) {
            $breaker1FailureCount = $event->getCircuit()->getFailures();
        });

        $fn = function () {
            throw new CustomException("An error as occurred");
        };

        try {
            $breaker->protect($fn);
        } catch (CustomException $e) {
            $this->assertInstanceOf('Eljam\CircuitBreaker\Exception\CustomException', $e);
        }
        $this->assertSame(0, $breaker1FailureCount);
    }

    public function tearDown()
    {
        @unlink($this->dir);

It seems like you do not handle an error condition here. This can introduce security issues, and is generally not recommended.

    }
}