1: <?php
  2: 
  3: /*
  4:  * This file is part of the Symfony package.
  5:  *
  6:  * (c) Fabien Potencier <fabien@symfony.com>
  7:  *
  8:  * For the full copyright and license information, please view the LICENSE
  9:  * file that was distributed with this source code.
 10:  */
 11: 
 12: namespace Symfony\Component\EventDispatcher\Tests\DependencyInjection;
 13: 
 14: use Symfony\Component\DependencyInjection\ContainerBuilder;
 15: use Symfony\Component\EventDispatcher\DependencyInjection\RegisterListenersPass;
 16: 
 17: class RegisterListenersPassTest extends \PHPUnit_Framework_TestCase
 18: {
 19:     /**
 20:      * Tests that event subscribers not implementing EventSubscriberInterface
 21:      * trigger an exception.
 22:      *
 23:      * @expectedException \InvalidArgumentException
 24:      */
 25:     public function testEventSubscriberWithoutInterface()
 26:     {
 27:         // one service, not implementing any interface
 28:         $services = array(
 29:             'my_event_subscriber' => array(0 => array()),
 30:         );
 31: 
 32:         $definition = $this->getMock('Symfony\Component\DependencyInjection\Definition');
 33:         $definition->expects($this->atLeastOnce())
 34:             ->method('isPublic')
 35:             ->will($this->returnValue(true));
 36:         $definition->expects($this->atLeastOnce())
 37:             ->method('getClass')
 38:             ->will($this->returnValue('stdClass'));
 39: 
 40:         $builder = $this->getMock(
 41:             'Symfony\Component\DependencyInjection\ContainerBuilder',
 42:             array('hasDefinition', 'findTaggedServiceIds', 'getDefinition')
 43:         );
 44:         $builder->expects($this->any())
 45:             ->method('hasDefinition')
 46:             ->will($this->returnValue(true));
 47: 
 48:         // We don't test kernel.event_listener here
 49:         $builder->expects($this->atLeastOnce())
 50:             ->method('findTaggedServiceIds')
 51:             ->will($this->onConsecutiveCalls(array(), $services));
 52: 
 53:         $builder->expects($this->atLeastOnce())
 54:             ->method('getDefinition')
 55:             ->will($this->returnValue($definition));
 56: 
 57:         $registerListenersPass = new RegisterListenersPass();
 58:         $registerListenersPass->process($builder);
 59:     }
 60: 
 61:     public function testValidEventSubscriber()
 62:     {
 63:         $services = array(
 64:             'my_event_subscriber' => array(0 => array()),
 65:         );
 66: 
 67:         $definition = $this->getMock('Symfony\Component\DependencyInjection\Definition');
 68:         $definition->expects($this->atLeastOnce())
 69:             ->method('isPublic')
 70:             ->will($this->returnValue(true));
 71:         $definition->expects($this->atLeastOnce())
 72:             ->method('getClass')
 73:             ->will($this->returnValue('Symfony\Component\EventDispatcher\Tests\DependencyInjection\SubscriberService'));
 74: 
 75:         $builder = $this->getMock(
 76:             'Symfony\Component\DependencyInjection\ContainerBuilder',
 77:             array('hasDefinition', 'findTaggedServiceIds', 'getDefinition', 'findDefinition')
 78:         );
 79:         $builder->expects($this->any())
 80:             ->method('hasDefinition')
 81:             ->will($this->returnValue(true));
 82: 
 83:         // We don't test kernel.event_listener here
 84:         $builder->expects($this->atLeastOnce())
 85:             ->method('findTaggedServiceIds')
 86:             ->will($this->onConsecutiveCalls(array(), $services));
 87: 
 88:         $builder->expects($this->atLeastOnce())
 89:             ->method('getDefinition')
 90:             ->will($this->returnValue($definition));
 91: 
 92:         $builder->expects($this->atLeastOnce())
 93:             ->method('findDefinition')
 94:             ->will($this->returnValue($definition));
 95: 
 96:         $registerListenersPass = new RegisterListenersPass();
 97:         $registerListenersPass->process($builder);
 98:     }
 99: 
100:     /**
101:      * @expectedException \InvalidArgumentException
102:      * @expectedExceptionMessage The service "foo" must be public as event listeners are lazy-loaded.
103:      */
104:     public function testPrivateEventListener()
105:     {
106:         $container = new ContainerBuilder();
107:         $container->register('foo', 'stdClass')->setPublic(false)->addTag('kernel.event_listener', array());
108:         $container->register('event_dispatcher', 'stdClass');
109: 
110:         $registerListenersPass = new RegisterListenersPass();
111:         $registerListenersPass->process($container);
112:     }
113: 
114:     /**
115:      * @expectedException \InvalidArgumentException
116:      * @expectedExceptionMessage The service "foo" must be public as event subscribers are lazy-loaded.
117:      */
118:     public function testPrivateEventSubscriber()
119:     {
120:         $container = new ContainerBuilder();
121:         $container->register('foo', 'stdClass')->setPublic(false)->addTag('kernel.event_subscriber', array());
122:         $container->register('event_dispatcher', 'stdClass');
123: 
124:         $registerListenersPass = new RegisterListenersPass();
125:         $registerListenersPass->process($container);
126:     }
127: 
128:     /**
129:      * @expectedException \InvalidArgumentException
130:      * @expectedExceptionMessage The service "foo" must not be abstract as event listeners are lazy-loaded.
131:      */
132:     public function testAbstractEventListener()
133:     {
134:         $container = new ContainerBuilder();
135:         $container->register('foo', 'stdClass')->setAbstract(true)->addTag('kernel.event_listener', array());
136:         $container->register('event_dispatcher', 'stdClass');
137: 
138:         $registerListenersPass = new RegisterListenersPass();
139:         $registerListenersPass->process($container);
140:     }
141: 
142:     /**
143:      * @expectedException \InvalidArgumentException
144:      * @expectedExceptionMessage The service "foo" must not be abstract as event subscribers are lazy-loaded.
145:      */
146:     public function testAbstractEventSubscriber()
147:     {
148:         $container = new ContainerBuilder();
149:         $container->register('foo', 'stdClass')->setAbstract(true)->addTag('kernel.event_subscriber', array());
150:         $container->register('event_dispatcher', 'stdClass');
151: 
152:         $registerListenersPass = new RegisterListenersPass();
153:         $registerListenersPass->process($container);
154:     }
155: 
156:     public function testEventSubscriberResolvableClassName()
157:     {
158:         $container = new ContainerBuilder();
159: 
160:         $container->setParameter('subscriber.class', 'Symfony\Component\EventDispatcher\Tests\DependencyInjection\SubscriberService');
161:         $container->register('foo', '%subscriber.class%')->addTag('kernel.event_subscriber', array());
162:         $container->register('event_dispatcher', 'stdClass');
163: 
164:         $registerListenersPass = new RegisterListenersPass();
165:         $registerListenersPass->process($container);
166: 
167:         $definition = $container->getDefinition('event_dispatcher');
168:         $expected_calls = array(
169:             array(
170:                 'addSubscriberService',
171:                 array(
172:                     'foo',
173:                     'Symfony\Component\EventDispatcher\Tests\DependencyInjection\SubscriberService',
174:                 ),
175:             ),
176:         );
177:         $this->assertSame($expected_calls, $definition->getMethodCalls());
178:     }
179: 
180:     /**
181:      * @expectedException \InvalidArgumentException
182:      * @expectedExceptionMessage You have requested a non-existent parameter "subscriber.class"
183:      */
184:     public function testEventSubscriberUnresolvableClassName()
185:     {
186:         $container = new ContainerBuilder();
187:         $container->register('foo', '%subscriber.class%')->addTag('kernel.event_subscriber', array());
188:         $container->register('event_dispatcher', 'stdClass');
189: 
190:         $registerListenersPass = new RegisterListenersPass();
191:         $registerListenersPass->process($container);
192:     }
193: }
194: 
195: class SubscriberService implements \Symfony\Component\EventDispatcher\EventSubscriberInterface
196: {
197:     public static function getSubscribedEvents()
198:     {
199:     }
200: }
201: