JVelasco\CircuitBreaker\CircuitBreakerTest

Complexity

Total Complexity

5

Size/Duplication

Total Lines	87
Duplicated Lines	0 %

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
A	it_throw_custom_exceptions_from_storage_increment_failures()	0	18	1
A	it_delegates_to_storage_counter_for_successes()	0	12	1
A	it_delegates_to_strategy_for_availability()	0	15	1
A	it_delegates_to_storage_counter_for_failures()	0	12	1
A	it_throw_custom_exceptions_from_storage_decrement_failures()	0	15	1

<?php

namespace JVelasco\CircuitBreaker;

use Exception;
use PHPUnit\Framework\TestCase;

class CircuitBreakerTest extends TestCase
{
    /** @test */
    public function it_delegates_to_strategy_for_availability()
    {
        $strategy = $this->prophesize(AvailabilityStrategy::class);
        $anAvailableService = "available";
        $strategy->isAvailable($anAvailableService)->willReturn(true);
        $aNotAvailableService = "not available";
        $strategy->isAvailable($aNotAvailableService)->willReturn(false);

        $circuitBreaker = new CircuitBreaker(
            $strategy->reveal(),
            $this->prophesize(FailuresCounterStorage::class)->reveal()
        );

        $this->assertTrue($circuitBreaker->isAvailable($anAvailableService));
        $this->assertFalse($circuitBreaker->isAvailable($aNotAvailableService));
    }

    /** @test */
    public function it_delegates_to_storage_counter_for_failures()
    {
        $storage = $this->prophesize(FailuresCounterStorage::class);
        $aService = "a service";
        $storage->incrementFailures($aService)->shouldBeCalledTimes(1);

        $circuitBreaker = new CircuitBreaker(
            $this->prophesize(AvailabilityStrategy::class)->reveal(),
            $storage->reveal()
        );

        $circuitBreaker->reportFailure($aService);
    }

    /** @test */
    public function it_delegates_to_storage_counter_for_successes()
    {
        $storage = $this->prophesize(FailuresCounterStorage::class);
        $aService = "a service";
        $storage->decrementFailures($aService)->shouldBeCalledTimes(1);

        $circuitBreaker = new CircuitBreaker(
            $this->prophesize(AvailabilityStrategy::class)->reveal(),
            $storage->reveal()
        );

        $circuitBreaker->reportSuccess($aService);
    }

    /** @test */
    public function it_throw_custom_exceptions_from_storage_increment_failures()
    {
        $storage = $this->prophesize(FailuresCounterStorage::class);

        $circuitBreaker = new CircuitBreaker(
            $this->prophesize(AvailabilityStrategy::class)->reveal(),
            $storage->reveal()
        );
        $aService = "a service";

        $storage->incrementFailures($aService)->willThrow(new Exception);
        $this->expectException(StorageException::class);
        $circuitBreaker->reportFailure($aService);

        $storage->decrementFailures($aService)->willThrow(new Exception);
        $this->expectException(StorageException::class);
        $this->expectExceptionMessage("Error incrementing failures");
        $circuitBreaker->reportSuccess($aService);
    }

    /** @test */
    public function it_throw_custom_exceptions_from_storage_decrement_failures()
    {
        $storage = $this->prophesize(FailuresCounterStorage::class);

        $circuitBreaker = new CircuitBreaker(
            $this->prophesize(AvailabilityStrategy::class)->reveal(),
            $storage->reveal()
        );

        $aService = "a service";

        $storage->decrementFailures($aService)->willThrow(new Exception);
        $this->expectException(StorageException::class);
        $this->expectExceptionMessage("Error decrementing failures");
        $circuitBreaker->reportSuccess($aService);
    }
}