class YamlFileLoaderTest in Zircon Profile 8

Hierarchy

• class \Symfony\Component\DependencyInjection\Tests\Loader\YamlFileLoaderTest extends \Symfony\Component\DependencyInjection\Tests\Loader\PHPUnit_Framework_TestCase

File

vendor/symfony/dependency-injection/Tests/Loader/YamlFileLoaderTest.php, line 24

Namespace

Symfony\Component\DependencyInjection\Tests\Loader

class YamlFileLoaderTest extends \PHPUnit_Framework_TestCase {
  protected static $fixturesPath;
  public static function setUpBeforeClass() {
    self::$fixturesPath = realpath(__DIR__ . '/../Fixtures/');
    require_once self::$fixturesPath . '/includes/foo.php';
    require_once self::$fixturesPath . '/includes/ProjectExtension.php';
  }
  public function testLoadFile() {
    $loader = new YamlFileLoader(new ContainerBuilder(), new FileLocator(self::$fixturesPath . '/ini'));
    $r = new \ReflectionObject($loader);
    $m = $r
      ->getMethod('loadFile');
    $m
      ->setAccessible(true);
    try {
      $m
        ->invoke($loader, 'foo.yml');
      $this
        ->fail('->load() throws an InvalidArgumentException if the loaded file does not exist');
    } catch (\Exception $e) {
      $this
        ->assertInstanceOf('\\InvalidArgumentException', $e, '->load() throws an InvalidArgumentException if the loaded file does not exist');
      $this
        ->assertEquals('The service file "foo.yml" is not valid.', $e
        ->getMessage(), '->load() throws an InvalidArgumentException if the loaded file does not exist');
    }
    try {
      $m
        ->invoke($loader, 'parameters.ini');
      $this
        ->fail('->load() throws an InvalidArgumentException if the loaded file is not a valid YAML file');
    } catch (\Exception $e) {
      $this
        ->assertInstanceOf('\\InvalidArgumentException', $e, '->load() throws an InvalidArgumentException if the loaded file is not a valid YAML file');
      $this
        ->assertEquals('The service file "parameters.ini" is not valid.', $e
        ->getMessage(), '->load() throws an InvalidArgumentException if the loaded file is not a valid YAML file');
    }
    $loader = new YamlFileLoader(new ContainerBuilder(), new FileLocator(self::$fixturesPath . '/yaml'));
    foreach (array(
      'nonvalid1',
      'nonvalid2',
    ) as $fixture) {
      try {
        $m
          ->invoke($loader, $fixture . '.yml');
        $this
          ->fail('->load() throws an InvalidArgumentException if the loaded file does not validate');
      } catch (\Exception $e) {
        $this
          ->assertInstanceOf('\\InvalidArgumentException', $e, '->load() throws an InvalidArgumentException if the loaded file does not validate');
        $this
          ->assertStringMatchesFormat('The service file "nonvalid%d.yml" is not valid.', $e
          ->getMessage(), '->load() throws an InvalidArgumentException if the loaded file does not validate');
      }
    }
  }

  /**
   * @dataProvider provideInvalidFiles
   * @expectedException \Symfony\Component\DependencyInjection\Exception\InvalidArgumentException
   */
  public function testLoadInvalidFile($file) {
    $loader = new YamlFileLoader(new ContainerBuilder(), new FileLocator(self::$fixturesPath . '/yaml'));
    $loader
      ->load($file . '.yml');
  }
  public function provideInvalidFiles() {
    return array(
      array(
        'bad_parameters',
      ),
      array(
        'bad_imports',
      ),
      array(
        'bad_import',
      ),
      array(
        'bad_services',
      ),
      array(
        'bad_service',
      ),
      array(
        'bad_calls',
      ),
      array(
        'bad_format',
      ),
    );
  }
  public function testLoadParameters() {
    $container = new ContainerBuilder();
    $loader = new YamlFileLoader($container, new FileLocator(self::$fixturesPath . '/yaml'));
    $loader
      ->load('services2.yml');
    $this
      ->assertEquals(array(
      'foo' => 'bar',
      'mixedcase' => array(
        'MixedCaseKey' => 'value',
      ),
      'values' => array(
        true,
        false,
        0,
        1000.3,
      ),
      'bar' => 'foo',
      'escape' => '@escapeme',
      'foo_bar' => new Reference('foo_bar'),
    ), $container
      ->getParameterBag()
      ->all(), '->load() converts YAML keys to lowercase');
  }
  public function testLoadImports() {
    $container = new ContainerBuilder();
    $resolver = new LoaderResolver(array(
      new IniFileLoader($container, new FileLocator(self::$fixturesPath . '/yaml')),
      new XmlFileLoader($container, new FileLocator(self::$fixturesPath . '/yaml')),
      new PhpFileLoader($container, new FileLocator(self::$fixturesPath . '/php')),
      $loader = new YamlFileLoader($container, new FileLocator(self::$fixturesPath . '/yaml')),
    ));
    $loader
      ->setResolver($resolver);
    $loader
      ->load('services4.yml');
    $actual = $container
      ->getParameterBag()
      ->all();
    $expected = array(
      'foo' => 'bar',
      'values' => array(
        true,
        false,
      ),
      'bar' => '%foo%',
      'escape' => '@escapeme',
      'foo_bar' => new Reference('foo_bar'),
      'mixedcase' => array(
        'MixedCaseKey' => 'value',
      ),
      'imported_from_ini' => true,
      'imported_from_xml' => true,
    );
    $this
      ->assertEquals(array_keys($expected), array_keys($actual), '->load() imports and merges imported files');

    // Bad import throws no exception due to ignore_errors value.
    $loader
      ->load('services4_bad_import.yml');
  }

  /**
   * @group legacy
   */
  public function testLegacyLoadServices() {
    $container = new ContainerBuilder();
    $loader = new YamlFileLoader($container, new FileLocator(self::$fixturesPath . '/yaml'));
    $loader
      ->load('legacy-services6.yml');
    $services = $container
      ->getDefinitions();
    $this
      ->assertEquals('FooClass', $services['constructor']
      ->getClass());
    $this
      ->assertEquals('getInstance', $services['constructor']
      ->getFactoryMethod());
    $this
      ->assertEquals('BazClass', $services['factory_service']
      ->getClass());
    $this
      ->assertEquals('baz_factory', $services['factory_service']
      ->getFactoryService());
    $this
      ->assertEquals('getInstance', $services['factory_service']
      ->getFactoryMethod());
    $this
      ->assertTrue($services['request']
      ->isSynthetic(), '->load() parses the synthetic flag');
    $this
      ->assertTrue($services['request']
      ->isSynchronized(), '->load() parses the synchronized flag');
    $this
      ->assertTrue($services['request']
      ->isLazy(), '->load() parses the lazy flag');
    $this
      ->assertNull($services['request']
      ->getDecoratedService());
  }
  public function testLoadServices() {
    $container = new ContainerBuilder();
    $loader = new YamlFileLoader($container, new FileLocator(self::$fixturesPath . '/yaml'));
    $loader
      ->load('services6.yml');
    $services = $container
      ->getDefinitions();
    $this
      ->assertTrue(isset($services['foo']), '->load() parses service elements');
    $this
      ->assertInstanceOf('Symfony\\Component\\DependencyInjection\\Definition', $services['foo'], '->load() converts service element to Definition instances');
    $this
      ->assertEquals('FooClass', $services['foo']
      ->getClass(), '->load() parses the class attribute');
    $this
      ->assertEquals('container', $services['scope.container']
      ->getScope());
    $this
      ->assertEquals('custom', $services['scope.custom']
      ->getScope());
    $this
      ->assertEquals('prototype', $services['scope.prototype']
      ->getScope());
    $this
      ->assertEquals('%path%/foo.php', $services['file']
      ->getFile(), '->load() parses the file tag');
    $this
      ->assertEquals(array(
      'foo',
      new Reference('foo'),
      array(
        true,
        false,
      ),
    ), $services['arguments']
      ->getArguments(), '->load() parses the argument tags');
    $this
      ->assertEquals('sc_configure', $services['configurator1']
      ->getConfigurator(), '->load() parses the configurator tag');
    $this
      ->assertEquals(array(
      new Reference('baz'),
      'configure',
    ), $services['configurator2']
      ->getConfigurator(), '->load() parses the configurator tag');
    $this
      ->assertEquals(array(
      'BazClass',
      'configureStatic',
    ), $services['configurator3']
      ->getConfigurator(), '->load() parses the configurator tag');
    $this
      ->assertEquals(array(
      array(
        'setBar',
        array(),
      ),
      array(
        'setBar',
        array(),
      ),
      array(
        'setBar',
        array(
          new Expression('service("foo").foo() ~ (container.hasparameter("foo") ? parameter("foo") : "default")'),
        ),
      ),
    ), $services['method_call1']
      ->getMethodCalls(), '->load() parses the method_call tag');
    $this
      ->assertEquals(array(
      array(
        'setBar',
        array(
          'foo',
          new Reference('foo'),
          array(
            true,
            false,
          ),
        ),
      ),
    ), $services['method_call2']
      ->getMethodCalls(), '->load() parses the method_call tag');
    $this
      ->assertEquals('factory', $services['new_factory1']
      ->getFactory(), '->load() parses the factory tag');
    $this
      ->assertEquals(array(
      new Reference('baz'),
      'getClass',
    ), $services['new_factory2']
      ->getFactory(), '->load() parses the factory tag');
    $this
      ->assertEquals(array(
      'BazClass',
      'getInstance',
    ), $services['new_factory3']
      ->getFactory(), '->load() parses the factory tag');
    $aliases = $container
      ->getAliases();
    $this
      ->assertTrue(isset($aliases['alias_for_foo']), '->load() parses aliases');
    $this
      ->assertEquals('foo', (string) $aliases['alias_for_foo'], '->load() parses aliases');
    $this
      ->assertTrue($aliases['alias_for_foo']
      ->isPublic());
    $this
      ->assertTrue(isset($aliases['another_alias_for_foo']));
    $this
      ->assertEquals('foo', (string) $aliases['another_alias_for_foo']);
    $this
      ->assertFalse($aliases['another_alias_for_foo']
      ->isPublic());
    $this
      ->assertEquals(array(
      'decorated',
      null,
    ), $services['decorator_service']
      ->getDecoratedService());
    $this
      ->assertEquals(array(
      'decorated',
      'decorated.pif-pouf',
    ), $services['decorator_service_with_name']
      ->getDecoratedService());
  }
  public function testLoadFactoryShortSyntax() {
    $container = new ContainerBuilder();
    $loader = new YamlFileLoader($container, new FileLocator(self::$fixturesPath . '/yaml'));
    $loader
      ->load('services14.yml');
    $services = $container
      ->getDefinitions();
    $this
      ->assertEquals(array(
      new Reference('baz'),
      'getClass',
    ), $services['factory']
      ->getFactory(), '->load() parses the factory tag with service:method');
    $this
      ->assertEquals(array(
      'FooBacFactory',
      'createFooBar',
    ), $services['factory_with_static_call']
      ->getFactory(), '->load() parses the factory tag with Class::method');
  }
  public function testExtensions() {
    $container = new ContainerBuilder();
    $container
      ->registerExtension(new \ProjectExtension());
    $loader = new YamlFileLoader($container, new FileLocator(self::$fixturesPath . '/yaml'));
    $loader
      ->load('services10.yml');
    $container
      ->compile();
    $services = $container
      ->getDefinitions();
    $parameters = $container
      ->getParameterBag()
      ->all();
    $this
      ->assertTrue(isset($services['project.service.bar']), '->load() parses extension elements');
    $this
      ->assertTrue(isset($parameters['project.parameter.bar']), '->load() parses extension elements');
    $this
      ->assertEquals('BAR', $services['project.service.foo']
      ->getClass(), '->load() parses extension elements');
    $this
      ->assertEquals('BAR', $parameters['project.parameter.foo'], '->load() parses extension elements');
    try {
      $loader
        ->load('services11.yml');
      $this
        ->fail('->load() throws an InvalidArgumentException if the tag is not valid');
    } catch (\Exception $e) {
      $this
        ->assertInstanceOf('\\InvalidArgumentException', $e, '->load() throws an InvalidArgumentException if the tag is not valid');
      $this
        ->assertStringStartsWith('There is no extension able to load the configuration for "foobarfoobar" (in', $e
        ->getMessage(), '->load() throws an InvalidArgumentException if the tag is not valid');
    }
  }

  /**
   * @covers Symfony\Component\DependencyInjection\Loader\YamlFileLoader::supports
   */
  public function testSupports() {
    $loader = new YamlFileLoader(new ContainerBuilder(), new FileLocator());
    $this
      ->assertTrue($loader
      ->supports('foo.yml'), '->supports() returns true if the resource is loadable');
    $this
      ->assertTrue($loader
      ->supports('foo.yaml'), '->supports() returns true if the resource is loadable');
    $this
      ->assertFalse($loader
      ->supports('foo.foo'), '->supports() returns true if the resource is loadable');
  }
  public function testNonArrayTagsThrowsException() {
    $loader = new YamlFileLoader(new ContainerBuilder(), new FileLocator(self::$fixturesPath . '/yaml'));
    try {
      $loader
        ->load('badtag1.yml');
      $this
        ->fail('->load() should throw an exception when the tags key of a service is not an array');
    } catch (\Exception $e) {
      $this
        ->assertInstanceOf('Symfony\\Component\\DependencyInjection\\Exception\\InvalidArgumentException', $e, '->load() throws an InvalidArgumentException if the tags key is not an array');
      $this
        ->assertStringStartsWith('Parameter "tags" must be an array for service', $e
        ->getMessage(), '->load() throws an InvalidArgumentException if the tags key is not an array');
    }
  }

  /**
   * @expectedException \Symfony\Component\DependencyInjection\Exception\InvalidArgumentException
   * @expectedExceptionMessage A "tags" entry must be an array for service
   */
  public function testNonArrayTagThrowsException() {
    $loader = new YamlFileLoader(new ContainerBuilder(), new FileLocator(self::$fixturesPath . '/yaml'));
    $loader
      ->load('badtag4.yml');
  }
  public function testTagWithoutNameThrowsException() {
    $loader = new YamlFileLoader(new ContainerBuilder(), new FileLocator(self::$fixturesPath . '/yaml'));
    try {
      $loader
        ->load('badtag2.yml');
      $this
        ->fail('->load() should throw an exception when a tag is missing the name key');
    } catch (\Exception $e) {
      $this
        ->assertInstanceOf('Symfony\\Component\\DependencyInjection\\Exception\\InvalidArgumentException', $e, '->load() throws an InvalidArgumentException if a tag is missing the name key');
      $this
        ->assertStringStartsWith('A "tags" entry is missing a "name" key for service ', $e
        ->getMessage(), '->load() throws an InvalidArgumentException if a tag is missing the name key');
    }
  }
  public function testTagWithAttributeArrayThrowsException() {
    $loader = new YamlFileLoader(new ContainerBuilder(), new FileLocator(self::$fixturesPath . '/yaml'));
    try {
      $loader
        ->load('badtag3.yml');
      $this
        ->fail('->load() should throw an exception when a tag-attribute is not a scalar');
    } catch (\Exception $e) {
      $this
        ->assertInstanceOf('Symfony\\Component\\DependencyInjection\\Exception\\InvalidArgumentException', $e, '->load() throws an InvalidArgumentException if a tag-attribute is not a scalar');
      $this
        ->assertStringStartsWith('A "tags" attribute must be of a scalar-type for service "foo_service", tag "foo", attribute "bar"', $e
        ->getMessage(), '->load() throws an InvalidArgumentException if a tag-attribute is not a scalar');
    }
  }
  public function testLoadYamlOnlyWithKeys() {
    $container = new ContainerBuilder();
    $loader = new YamlFileLoader($container, new FileLocator(self::$fixturesPath . '/yaml'));
    $loader
      ->load('services21.yml');
    $definition = $container
      ->getDefinition('manager');
    $this
      ->assertEquals(array(
      array(
        'setLogger',
        array(
          new Reference('logger'),
        ),
      ),
      array(
        'setClass',
        array(
          'User',
        ),
      ),
    ), $definition
      ->getMethodCalls());
    $this
      ->assertEquals(array(
      true,
    ), $definition
      ->getArguments());
    $this
      ->assertEquals(array(
      'manager' => array(
        array(
          'alias' => 'user',
        ),
      ),
    ), $definition
      ->getTags());
  }

}

Members

Name	Modifiers	Type	Description	Overrides
YamlFileLoaderTest::$fixturesPath	protected static	property
YamlFileLoaderTest::provideInvalidFiles	public	function
YamlFileLoaderTest::setUpBeforeClass	public static	function
YamlFileLoaderTest::testExtensions	public	function
YamlFileLoaderTest::testLegacyLoadServices	public	function	@group legacy
YamlFileLoaderTest::testLoadFactoryShortSyntax	public	function
YamlFileLoaderTest::testLoadFile	public	function
YamlFileLoaderTest::testLoadImports	public	function
YamlFileLoaderTest::testLoadInvalidFile	public	function	@dataProvider provideInvalidFiles @expectedException \Symfony\Component\DependencyInjection\Exception\InvalidArgumentException
YamlFileLoaderTest::testLoadParameters	public	function
YamlFileLoaderTest::testLoadServices	public	function
YamlFileLoaderTest::testLoadYamlOnlyWithKeys	public	function
YamlFileLoaderTest::testNonArrayTagsThrowsException	public	function
YamlFileLoaderTest::testNonArrayTagThrowsException	public	function	@expectedException \Symfony\Component\DependencyInjection\Exception\InvalidArgumentException @expectedExceptionMessage A "tags" entry must be an array for service
YamlFileLoaderTest::testSupports	public	function	@covers Symfony\Component\DependencyInjection\Loader\YamlFileLoader::supports
YamlFileLoaderTest::testTagWithAttributeArrayThrowsException	public	function
YamlFileLoaderTest::testTagWithoutNameThrowsException	public	function