Symfony2: Jak przetestować wartości węzłów konfiguracji i indeks

Question

W Symfony2, używając tej konfiguracji klas, jak mogę przetestować, czy każdy węzeł jest zdefiniowany w klasie Configuration i czy ich wartości są poprawnie skonfigurowane.

Klasa przetestować

 
# My\Bundle\DependencyInjection\Configuration.php 

class Configuration implements ConfigurationInterface 
{ 
    /** 
    * {@inheritDoc} 
    */ 
    public function getConfigTreeBuilder() 
    { 
     $treeBuilder = new TreeBuilder(); 
     $treeBuilder->root('my_bundle') 
      ->children() 
       ->scalarNode("scalar")->defaultValue("defaultValue")->end() 
       ->arrayNode("arrayNode") 
        ->children() 
         ->scalarNode("val1")->defaultValue("defaultValue1")->end() 
         ->scalarNode("val2")->defaultValue("defaultValue2")->end() 
        ->end() 
       ->end() 
      ->end() 
     ; 

     return $treeBuilder; 
    } 
} 

Oto twierdzenia chciałbym zrobić w moim badanej jednostki:

I próbuje uzyskać dostęp do węzłów jako tablica, ale nie wydaje się działać. Również wydaje się, że TreeBuilder nie daje nam możliwości uzyskania konfiguracji jako tablicy, chyba że są one ładowane przez rozszerzenie pakietu.

Testy

 
# My\Bundle\Tests\DependencyInjection\ConfigurationTest.php 

$configuration = $this->getConfiguration(); 
$treeBuilder = $configuration->getConfigTreeBuilder(); 

$this->assertInstanceOf("Symfony\Component\Config\Definition\Builder\TreeBuilder", $treeBuilder); 

// How to access the treebuilder's nodes ? 
$rootNode = $treeBuilder["my_bundle"]; 
$scalarNode = $treeBuilder["scalar"]; 
$arrayNode = $treeBuilder["arrayNode"]; 
$val1Node = $arrayNode["val1"]; 
$val2Node = $arrayNode["val2"]; 

$this->assertInstanceOf("Symfony\...\ArrayNodeDefinition", $rootNode); 
$this->assertEquals("defaultValue", $scalarNode, "Test the default value of the node"); 
$this->assertEquals("defaultValue", $val1Node, "Test the default value of the node"); 
$this->assertEquals("defaultValue", $val2Node, "Test the default value of the node"); 

Answer 1

I okazało się rozwiązanie, które może działać w oparciu o JMSSecurityBundle.

Zamiast testować konfigurację, testuję rozszerzenie, które dodadzą pokrycia dla konfiguracji. W ten sposób mogę stwierdzić, że została ustawiona domyślna konfiguracja. Na przykład: Extension.

#My\Bundle\DependencyInjection\MyBundleExtension 
class MyBundleExtension extends Extension 
{ 
    /** 
    * {@inheritDoc} 
    */ 
    public function load(array $configs, ContainerBuilder $container) 
    { 
     $configuration = new Configuration(); 
     $config  = $this->processConfiguration($configuration, $configs); 

     $container->setParameter("crak_landing_frontend.scalar", $config["scalar"]); 
     $container->setParameter("crak_landing_frontend.array_node", $config["array_node"]); 

     $loader = new Loader\XmlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config')); 
     $loader->load('services.xml'); 
    } 
} 

Could be testy jak:

#My\Bundle\Tests\DependencyInjection\MyBundleExtensionTest 
class MyBundleExtensionTest extends \PHPUnit_Framework_TestCase 
{ 
    /** 
    * @var MyBundleExtension 
    */ 
    private $extension; 

    /** 
    * Root name of the configuration 
    * 
    * @var string 
    */ 
    private $root; 

    public function setUp() 
    { 
     parent::setUp(); 

     $this->extension = $this->getExtension(); 
     $this->root  = "my_bundle"; 
    } 

    public function testGetConfigWithDefaultValues() 
    { 
     $this->extension->load(array(), $container = $this->getContainer()); 

     $this->assertTrue($container->hasParameter($this->root . ".scalar")); 
     $this->assertEquals("defaultValue", $container->getParameter($this->root . ".scalar")); 

     $expected = array(
      "val1" => "defaultValue1", 
      "val2" => "defaultValue2", 
     ); 
     $this->assertTrue($container->hasParameter($this->root . ".array_node")); 
     $this->assertEquals($expected, $container->getParameter($this->root . ".array_node")); 
    } 

    public function testGetConfigWithOverrideValues() 
    { 
     $configs = array(
      "scalar"  => "scalarValue", 
      "array_node" => array(
       "val1" => "array_value_1", 
       "val2" => "array_value_2", 
      ), 
     ); 

     $this->extension->load(array($configs), $container = $this->getContainer()); 

     $this->assertTrue($container->hasParameter($this->root . ".scalar")); 
     $this->assertEquals("scalarValue", $container->getParameter($this->root . ".scalar")); 

     $expected = array(
      "val1" => "array_value_1", 
      "val2" => "array_value_2", 
     ); 
     $this->assertTrue($container->hasParameter($this->root . ".array_node")); 
     $this->assertEquals($expected, $container->getParameter($this->root . ".array_node")); 
    } 

    /** 
    * @return MyBundleExtension 
    */ 
    protected function getExtension() 
    { 
     return new MyBundleExtension(); 
    } 

    /** 
    * @return ContainerBuilder 
    */ 
    private function getContainer() 
    { 
     $container = new ContainerBuilder(); 

     return $container; 
    } 
} 

Answer 2

Aby przetestować konfigurację w oderwaniu, można to zrobić:

use Foo\YourBundle\DependencyInjection\Configuration; 
use PHPUnit\Framework\TestCase; 

class ConfigurationTest extends TestCase 
{ 
    /** 
    * @dataProvider dataTestConfiguration 
    * 
    * @param mixed $inputConfig 
    * @param mixed $expectedConfig 
    */ 
    public function testConfiguration($inputConfig, $expectedConfig) 
    { 
     $configuration = new Configuration(); 

     $node = $configuration->getConfigTreeBuilder() 
      ->buildTree(); 
     $normalizedConfig = $node->normalize($inputConfig); 
     $finalizedConfig = $node->finalize($normalizedConfig); 

     $this->assertEquals($expectedConfig, $finalizedConfig); 
    } 

    public function dataTestConfiguration() 
    { 
     return [ 
      'test configuration' => [ 
       ['input'], 
       ['expected_config'] 
      ], 
      // ... 
     ]; 
    } 
}