Dummy1Aggregate::doSomething() - Code Metrics - SmartGecko/GovernorBundle - Measure and Improve Code Quality continuously with Scrutinizer

Dummy1Aggregate::doSomething() A
last analyzed 2015-12-21 19:45 UTC

↳ Parent: Dummy1Aggregate

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
dl	0
loc	4
rs	10
c	1
b	0
f	0
cc	1
eloc	1
nc	1
nop	1

<?php


namespace Governor\Tests\Plugin\SymfonyBundle;

use Governor\Bundle\GovernorBundle\DependencyInjection\Compiler\AggregateCommandHandlerPass;
use Governor\Framework\CommandHandling\Distributed\AnnotationRoutingStrategy;
use Governor\Framework\CommandHandling\Distributed\DistributedCommandBus;
use Governor\Framework\CommandHandling\Distributed\MetaDataRoutingStrategy;
use Psr\Log\LoggerInterface;
use Governor\Framework\CommandHandling\CommandBusInterface;
use Governor\Framework\CommandHandling\CommandHandlerInterface;
use Governor\Framework\CommandHandling\GenericCommandMessage;
use Governor\Framework\CommandHandling\NoHandlerForCommandException;
use Governor\Framework\Domain\AbstractAggregateRoot;
use Governor\Framework\Domain\IdentifierFactory;
use Governor\Framework\EventSourcing\Annotation\AbstractAnnotatedAggregateRoot;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\Definition;
use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag;
use Symfony\Component\DependencyInjection\Compiler\PassConfig;
use Governor\Bundle\GovernorBundle\DependencyInjection\GovernorFrameworkExtension;
use Governor\Bundle\GovernorBundle\DependencyInjection\Compiler\CommandHandlerPass;
use Governor\Bundle\GovernorBundle\DependencyInjection\Compiler\EventHandlerPass;
use Governor\Framework\Repository\RepositoryInterface;
use Governor\Framework\Annotations\EventHandler;
use Governor\Framework\Annotations\CommandHandler;
use Symfony\Bridge\ProxyManager\LazyProxy\Instantiator\RuntimeInstantiator;
use Governor\Framework\EventHandling\EventBusInterface;
use Governor\Framework\EventHandling\EventListenerInterface;
use Governor\Framework\CommandHandling\SimpleCommandBus;
use Governor\Framework\EventHandling\SimpleEventBus;
use Governor\Framework\CommandHandling\InMemoryCommandHandlerRegistry;
use Governor\Framework\EventHandling\InMemoryEventListenerRegistry;
use Symfony\Component\Stopwatch\Stopwatch;
use Governor\Framework\EventHandling\Amqp\AmqpTerminal;

$loader = require __DIR__."/../../vendor/autoload.php";
$loader->add('Governor', __DIR__);

\Doctrine\Common\Annotations\AnnotationRegistry::registerLoader(array($loader, 'loadClass'));

class GovernorFrameworkExtensionTest extends \PHPUnit_Framework_TestCase
{
    /**
     * @var ContainerInterface
     */
    private $testSubject;

    public function setUp()
    {
        $this->testSubject = $this->createTestContainer();
    }

    public function testRepositories()
    {
        $repo1 = $this->testSubject->get('dummy1.repository');
        $repo2 = $this->testSubject->get('dummy2.repository');

        $this->assertInstanceOf(RepositoryInterface::class, $repo1);
        $this->assertInstanceOf(RepositoryInterface::class, $repo2);
        $this->assertNotSame($repo1, $repo2);
        $this->assertEquals(
            Dummy1Aggregate::class,
            $repo1->getClass()
        );
        $this->assertEquals(
            Dummy2Aggregate::class,
            $repo2->getClass()
        );
    }

    public function testCommandHandlers()
    {
        /** @var CommandBusInterface $commandBus */
        $commandBus = $this->testSubject->get('governor.command_bus.default');
        $this->assertInstanceOf(CommandBusInterface::class, $commandBus);

        $handler = $commandBus->findCommandHandlerFor(GenericCommandMessage::asCommandMessage(new ContainerCommand1()));

        $this->assertInstanceOf(CommandHandlerInterface::class, $handler);

        try {
            $commandBus->findCommandHandlerFor(GenericCommandMessage::asCommandMessage(new \stdClass()));

            $this->fail('NoHandlerForCommandException expected');
        } catch (NoHandlerForCommandException $ex) {


        }
    }

    public function testEventHandlers()
    {
        /** @var EventBusInterface $eventBus */
        $eventBus = $this->testSubject->get('governor.event_bus.default');

        $this->assertInstanceOf(EventBusInterface::class, $eventBus);

        $registry = $eventBus->getEventListenerRegistry();
        $this->assertInstanceOf(InMemoryEventListenerRegistry::class, $registry);

        $listeners = $registry->getListeners();

        $this->assertCount(2, $listeners);
        $this->assertContainsOnlyInstancesOf(EventListenerInterface::class, $listeners);
    }

    public function testEventHandlerLazyLoading()

    {
        foreach ($this->testSubject->getServiceIds() as $id) {
            if (preg_match('/^governor.event_handler.*/', $id)) {
                $def = $this->testSubject->getDefinition($id);
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
                $this->assertTrue($def->isLazy());
            }
        }
    }

    public function testCommandHandlerLazyLoading()

    {
        foreach ($this->testSubject->getServiceIds() as $id) {
            if (preg_match('/^governor.command_handler.*/', $id) || preg_match(
                    '/^governor.aggregate_command_handler.*/',
                    $id
                )
            ) {
                $def = $this->testSubject->getDefinition($id);
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
                $this->assertTrue($def->isLazy());
            }
        }
    }

    public function testIdentifierFactory()
    {
        $factory = $this->testSubject->get('governor.identifier_factory');

        $this->assertInstanceOf(IdentifierFactory::class, $factory);
    }

    public function testAggregates()
    {
        $aggregates = $this->testSubject->getParameter('governor.aggregates');
        $this->assertCount(2, $aggregates);

        $this->assertTrue($aggregates['dummy1']['handler']);
        $this->assertFalse($aggregates['dummy2']['handler']);

        $this->assertEquals('default', $aggregates['dummy1']['command_bus']);
        $this->assertEquals('third', $aggregates['dummy2']['command_bus']);

        $count = 0;

        foreach ($this->testSubject->getServiceIds() as $id) {
            if (preg_match('/^governor.aggregate_command_handler.*/', $id)) {
                $def = $this->testSubject->getDefinition($id);
interface User
{
    /** @return string */
    public function getPassword();
}

class MyUser implements User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}

                $this->assertEquals(Dummy1Aggregate::class, $def->getArgument(0));
                $count++;;
            }
        }

        $this->assertEquals(1, $count);
    }

    public function testAmqp()
    {
        /** @var AmqpTerminal $terminal */
        $terminal = $this->testSubject->get('governor.terminal.amqp.default');
        $this->assertInstanceOf(AmqpTerminal::class, $terminal);

        $connection = $this->testSubject->get('governor.amqp.connection.default');
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
    }

    public function testEventBuses()
    {
        /** @var EventBusInterface $first */
        $first = $this->testSubject->get('governor.event_bus.default');
        /** @var EventBusInterface $second */
        $second = $this->testSubject->get('governor.event_bus.second');

        $this->assertInstanceOf(EventBusInterface::class, $first);
        $this->assertInstanceOf(EventBusInterface::class, $second);
    }

    public function testRoutingStrategies()
    {
        /** @var MetaDataRoutingStrategy $default */
        $default = $this->testSubject->get('governor.routing_strategy.default');
        $this->assertInstanceOf(MetaDataRoutingStrategy::class, $default);

        /** @var AnnotationRoutingStrategy $annotated */
        $annotated = $this->testSubject->get('governor.routing_strategy.annotated');
        $this->assertInstanceOf(AnnotationRoutingStrategy::class, $annotated);
    }

    public function testCommandBuses()
    {
        /** @var  SimpleCommandBus $simple */
        $simple = $this->testSubject->get('governor.command_bus.default');
        $this->assertInstanceOf(SimpleCommandBus::class, $simple);

        /** @var DistributedCommandBus $distributed */
        $distributed = $this->testSubject->get('governor.command_bus.distributed');
        $this->assertInstanceOf(DistributedCommandBus::class, $distributed);
    }

    public function createTestContainer()
    {

        $config = [
            'governor' => [
                'node_name' => 'test-01',
                'terminals' => [
                    'amqp' => [
                        'default' => [
                        ]
                    ]
                ],
                'connectors' => [
                    'redis' => [
                        'default' => [
                            'routing_strategy' => 'default',
                            'local_segment' => 'default'
                        ]
                    ]
                ],
                'routing_strategies' => [
                    'default' => [
                        'type' => 'metadata',
                        'parameters' => [
                            'key_name' => 'aggregateIdentifier'
                        ]
                    ],
                    'annotated' => [
                        'type' => 'annotation'
                    ]
                ],
                'annotation_reader' => [
                    'type' => 'file_cache',
                    'parameters' => [
                        'debug' => false,
                        'path' => '%kernel.cache_dir%'
                    ]
                ],
                'aggregates' => [
                    'dummy1' => [
                        'class' => Dummy1Aggregate::class,
                        'repository' => 'event_sourcing',
                        'handler' => true
                    ],
                    'dummy2' => [
                        'class' => Dummy2Aggregate::class,
                        'repository' => 'hybrid',
                        'handler' => false,
                        'command_bus' => 'third'
                    ]
                ],
                'command_buses' => [
                    'default' => [
                        'type' => 'simple'
                    ],
                    'distributed' => [
                        'type' => 'distributed',
                        'connector' => 'default',
                        'routing_strategy' => 'default'
                    ],
                    'third' => [
                        'type' => 'simple'
                    ],
                ],
                'event_buses' => [
                    'default' => [
                        'class' => SimpleEventBus::class,
                        'registry' => 'governor.event_bus_registry.in_memory',
                        'terminals' => [
                            'governor.terminal.amqp.default'
                        ]
                    ],
                    'second' => [
                        'class' => SimpleEventBus::class,
                        'registry' => 'governor.event_bus_registry.in_memory'
                    ]
                ],
                'event_store' => [
                    'mongo_templates' => [
                        'default' => [
                            'server' => 'mongodb://localhost:27017',
                            'database' => 'test'
                        ]
                    ],
                    'type' => 'mongo',
                    'parameters' => [

                    ]
                ],
                'command_gateways' => [
                    'default' => [
                        'class' => 'Governor\Framework\CommandHandling\Gateway\DefaultCommandGateway'
                    ]
                ],
                'saga_repository' => [
                    'mongo_templates' => [
                        'default' => [
                            'server' => 'mongodb://localhost:27017',
                            'database' => 'test2'
                        ]
                    ],
                    'type' => 'mongo',
                    'parameters' => [
                    ]
                ],
                'saga_manager' => [
                    'type' => 'annotation',
                    'saga_locations' => [
                        sys_get_temp_dir()
                    ]
                ],
                'order_resolver' => 'annotation'
            ]
        ];

        $container = new ContainerBuilder(
            new ParameterBag(
                [
                    'kernel.debug' => false,
                    'kernel.bundles' => [],
                    'kernel.cache_dir' => sys_get_temp_dir(),
                    'kernel.environment' => 'test',
                    'kernel.root_dir' => __DIR__.'/../../../../' // src dir
                ]
            )
        );

        $loader = new GovernorFrameworkExtension();

        $container->setProxyInstantiator(new RuntimeInstantiator());

        $container->registerExtension($loader);
        $container->set(
            'doctrine.orm.default_entity_manager',
            $this->getMock(
                \Doctrine\ORM\EntityManager::class,
                [
                    'find',
                    'flush',
                    'persist',
                    'remove'
                ],
                [],
                '',
                false
            )
        );

        $container->set('logger', $this->getMock(LoggerInterface::class));
        $container->set('debug.stopwatch', $this->getMock(Stopwatch::class));
        $container->set('jms_serializer', $this->getMock(\JMS\Serializer\SerializerInterface::class));
        $container->set('validator', $this->getMock(\Symfony\Component\Validator\ValidatorInterface::class));

        $this->addTaggedCommandHandlers($container);
        $this->addTaggedEventListeners($container);

        $loader->load($config, $container);

        $container->addCompilerPass(new CommandHandlerPass(), PassConfig::TYPE_BEFORE_REMOVING);
        $container->addCompilerPass(new EventHandlerPass(), PassConfig::TYPE_BEFORE_REMOVING);
        $container->addCompilerPass(new AggregateCommandHandlerPass(), PassConfig::TYPE_BEFORE_REMOVING);

        $container->compile();

        return $container;
    }

    private function addTaggedCommandHandlers(ContainerBuilder $container)

    {
        $definition = new Definition(ContainerCommandHandler1::class);
        $definition->addTag('governor.command_handler')
            ->setPublic(true);

        $container->setDefinition('test.command_handler', $definition);
    }

    private function addTaggedEventListeners(ContainerBuilder $container)

    {
        $definition = new Definition(ContainerEventListener1::class);
        $definition->addTag('governor.event_handler')
            ->setPublic(true);

        $container->setDefinition('test.event_handler', $definition);
    }

}

class Dummy1Aggregate extends AbstractAnnotatedAggregateRoot

{

    public function getIdentifier()
    {
        // TODO: Implement getIdentifier() method.
    }

    /**
     * @CommandHandler()
     * @param ContainerCommand2 $command
     */
    public function doSomething(ContainerCommand2 $command)

    {

    }

}

class Dummy2Aggregate extends AbstractAggregateRoot

{

    public function getIdentifier()
    {
        // TODO: Implement getIdentifier() method.
    }

}

class ContainerCommand1

{

}

class ContainerCommand2

{

}

class ContainerEvent1

{

}

class ContainerCommandHandler1

{

    /**
     * @param ContainerCommand1 $command
     * @CommandHandler
     */
    public function onCommand1(ContainerCommand1 $command)

    {

    }

}

class ContainerEventListener1

{

    /**
     * @EventHandler
     */
    public function onEvent1(ContainerEvent1 $event)

    {

    }

}


Dummy1Aggregate::doSomething() A
last analyzed 2015-12-21 19:45 UTC

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

1			<?php
			0 ignored issues – show Coding Style Compatibility introduced 2015-11-28 13:23 UTC by Report Bug Copy Issue Report For compatibility and reusability of your code, PSR1 recommends that a file should introduce either new symbols (like classes, functions, etc.) or have side-effects (like outputting something, or including other files), but not both at the same time. The first symbol is defined on line 43 and the first side effect is on line 38. The PSR-1: Basic Coding Standard recommends that a file should either introduce new symbols, that is classes, functions, constants or similar, or have side effects. Side effects are anything that executes logic, like for example printing output, changing ini settings or writing to a file. The idea behind this recommendation is that merely auto-loading a class should not change the state of an application. It also promotes a cleaner style of programming and makes your code less prone to errors, because the logic is not spread out all over the place. To learn more about the PSR-1, please see the PHP-FIG site on the PSR-1. Loading history...
2
3			namespace Governor\Tests\Plugin\SymfonyBundle;
4
5			use Governor\Bundle\GovernorBundle\DependencyInjection\Compiler\AggregateCommandHandlerPass;
6			use Governor\Framework\CommandHandling\Distributed\AnnotationRoutingStrategy;
7			use Governor\Framework\CommandHandling\Distributed\DistributedCommandBus;
8			use Governor\Framework\CommandHandling\Distributed\MetaDataRoutingStrategy;
9			use Psr\Log\LoggerInterface;
10			use Governor\Framework\CommandHandling\CommandBusInterface;
11			use Governor\Framework\CommandHandling\CommandHandlerInterface;
12			use Governor\Framework\CommandHandling\GenericCommandMessage;
13			use Governor\Framework\CommandHandling\NoHandlerForCommandException;
14			use Governor\Framework\Domain\AbstractAggregateRoot;
15			use Governor\Framework\Domain\IdentifierFactory;
16			use Governor\Framework\EventSourcing\Annotation\AbstractAnnotatedAggregateRoot;
17			use Symfony\Component\DependencyInjection\ContainerInterface;
18			use Symfony\Component\DependencyInjection\ContainerBuilder;
19			use Symfony\Component\DependencyInjection\Definition;
20			use Symfony\Component\DependencyInjection\ParameterBag\ParameterBag;
21			use Symfony\Component\DependencyInjection\Compiler\PassConfig;
22			use Governor\Bundle\GovernorBundle\DependencyInjection\GovernorFrameworkExtension;
23			use Governor\Bundle\GovernorBundle\DependencyInjection\Compiler\CommandHandlerPass;
24			use Governor\Bundle\GovernorBundle\DependencyInjection\Compiler\EventHandlerPass;
25			use Governor\Framework\Repository\RepositoryInterface;
26			use Governor\Framework\Annotations\EventHandler;
27			use Governor\Framework\Annotations\CommandHandler;
28			use Symfony\Bridge\ProxyManager\LazyProxy\Instantiator\RuntimeInstantiator;
29			use Governor\Framework\EventHandling\EventBusInterface;
30			use Governor\Framework\EventHandling\EventListenerInterface;
31			use Governor\Framework\CommandHandling\SimpleCommandBus;
32			use Governor\Framework\EventHandling\SimpleEventBus;
33			use Governor\Framework\CommandHandling\InMemoryCommandHandlerRegistry;
34			use Governor\Framework\EventHandling\InMemoryEventListenerRegistry;
35			use Symfony\Component\Stopwatch\Stopwatch;
36			use Governor\Framework\EventHandling\Amqp\AmqpTerminal;
37
38			$loader = require __DIR__."/../../vendor/autoload.php";
39			$loader->add('Governor', __DIR__);

SmartGecko / GovernorBundle

Dummy1Aggregate::doSomething() A last analyzed 2015-12-21 19:45 UTC

Complexity

Size

Duplication

Importance

Available Fixes

Available Fixes

Available Fixes

Duplication Side-by-Side

Filter issues like

Dummy1Aggregate::doSomething() A
last analyzed 2015-12-21 19:45 UTC