You are here

Home » API reference » Configuration Split 8

SplitFilterTest.php in Configuration Split 8

Namespace

Drupal\config_split\Tests

File

src/Tests/SplitFilterTest.php
View source 
<?php

namespace Drupal\config_split\Tests;

use Drupal\config_split\Plugin\ConfigFilter\SplitFilter;
use Drupal\Core\Config\DatabaseStorage;
use Drupal\Core\Config\FileStorage;
use Drupal\Core\Config\NullStorage;
use Drupal\Core\Config\StorageInterface;
use Drupal\Tests\UnitTestCase;
use org\bovigo\vfs\vfsStream;
use org\bovigo\vfs\vfsStreamFile;
use Prophecy\Argument;

/**
 * Test filter plugin.
 *
 * @group config_split
 */
class SplitFilterTest extends UnitTestCase {

  /**
   * Test that the blacklist is correctly calculated.
   */
  public function testBlacklist() {
    $configuration = [];
    $configuration['blacklist'] = [
      'a',
      'b',
    ];
    $configuration['graylist'] = [];
    $configuration['module'] = [
      'module1' => 0,
      'module2' => 0,
    ];
    $configuration['theme'] = [
      'theme1' => 0,
    ];
    $configuration['graylist_dependents'] = FALSE;

    // The config manager returns dependent entities for modules and themes.
    $manager = $this
      ->prophesize('Drupal\\Core\\Config\\ConfigManagerInterface');
    $manager
      ->findConfigEntityDependents(Argument::exact('module'), Argument::exact([
      'module1',
      'module2',
    ]))
      ->willReturn([
      'c' => 0,
      'd' => 0,
      'a' => 0,
    ]);
    $manager
      ->findConfigEntityDependents(Argument::exact('theme'), Argument::exact([
      'theme1',
    ]))
      ->willReturn([
      'e' => 0,
      'f' => 0,
      'c' => 0,
    ]);

    // Add a config storage returning some settings for the filtered modules.
    $all_config = array_merge(array_fill_keys(range("a", "z"), []), [
      'module1.settings' => [],
      'module3.settings' => [],
    ]);
    $manager
      ->getConfigFactory()
      ->willReturn($this
      ->getConfigStorageStub($all_config));

    // Add more config dependencies, independently of what is asked for.
    $manager
      ->findConfigEntityDependents(Argument::exact('config'), Argument::cetera())
      ->willReturn([
      'f' => 0,
      'g' => 0,
      'b' => 0,
    ]);
    $filter = new SplitFilter($configuration, 'config_split', [], $manager
      ->reveal());
    $actual = $filter
      ->getBlacklist();

    // The order of values and keys are not important.
    sort($actual);
    $expected = [
      'a',
      'b',
      'c',
      'd',
      'e',
      'f',
      'g',
      'module1.settings',
    ];
    $this
      ->assertArrayEquals($expected, $actual);
  }

  /**
   * Test that the graylist is correctly calculated.
   */
  public function testGraylist() {
    $configuration = [];
    $configuration['blacklist'] = [];
    $configuration['graylist'] = [
      'a',
      'b',
    ];
    $configuration['module'] = [];
    $configuration['theme'] = [];
    $configuration['graylist_dependents'] = TRUE;

    // The config manager returns dependent entities for modules and themes.
    $manager = $this
      ->prophesize('Drupal\\Core\\Config\\ConfigManagerInterface');
    $manager
      ->findConfigEntityDependents(Argument::exact('module'), Argument::cetera())
      ->willReturn([]);
    $manager
      ->findConfigEntityDependents(Argument::exact('theme'), Argument::cetera())
      ->willReturn([]);

    // Add a config storage returning some settings for the filtered modules.
    $all_config = array_merge(array_fill_keys(range("a", "z"), []), [
      'module1.settings' => [],
      'module3.settings' => [],
    ]);
    $manager
      ->getConfigFactory()
      ->willReturn($this
      ->getConfigStorageStub($all_config));

    // Add more config dependencies, independently of what is asked for.
    $manager
      ->findConfigEntityDependents(Argument::exact('config'), Argument::exact([]))
      ->willReturn([]);
    $manager
      ->findConfigEntityDependents(Argument::exact('config'), Argument::exact([
      'a',
      'b',
    ]))
      ->willReturn([
      'f' => 0,
      'g' => 0,
      'b' => 0,
    ]);
    $filter = new SplitFilter($configuration, 'config_split', [], $manager
      ->reveal());
    $actual = $filter
      ->getGraylist();

    // The order of values and keys are not important.
    sort($actual);
    $this
      ->assertArrayEquals([
      'a',
      'b',
      'f',
      'g',
    ], $actual);
  }

  /**
   * Test that conditionally split config will not be completely split.
   */
  public function testConditionallySplitInCompleteSplit() {
    $configuration = [];
    $configuration['blacklist'] = [
      'b',
      'c',
      'd',
    ];
    $configuration['graylist'] = [
      'a',
    ];
    $configuration['module'] = [];
    $configuration['theme'] = [];
    $configuration['graylist_dependents'] = TRUE;

    // The config manager returns dependent entities for modules and themes.
    $manager = $this
      ->prophesize('Drupal\\Core\\Config\\ConfigManagerInterface');
    $manager
      ->findConfigEntityDependents(Argument::exact('module'), Argument::cetera())
      ->willReturn([]);
    $manager
      ->findConfigEntityDependents(Argument::exact('theme'), Argument::cetera())
      ->willReturn([]);

    // Add a config storage returning some settings for the filtered modules.
    $all_config = array_merge(array_fill_keys(range("a", "z"), []), [
      'module1.settings' => [],
      'module3.settings' => [],
    ]);
    $manager
      ->getConfigFactory()
      ->willReturn($this
      ->getConfigStorageStub($all_config));

    // Add more config dependencies, independently of what is asked for.
    $manager
      ->findConfigEntityDependents(Argument::exact('config'), Argument::exact([
      'b',
      'c',
      'd',
    ]))
      ->willReturn([
      'e' => 0,
    ]);
    $manager
      ->findConfigEntityDependents(Argument::exact('config'), Argument::exact([
      'a',
    ]))
      ->willReturn([
      'f' => 0,
      'b' => 0,
    ]);
    $filter = new SplitFilter($configuration, 'config_split', [], $manager
      ->reveal());
    $actual = $filter
      ->getBlacklist();

    // The order of values and keys are not important.
    sort($actual);
    $this
      ->assertArrayEquals([
      'c',
      'd',
      'e',
    ], $actual);
  }

  /**
   * Test that the wildcards are properly taken into account.
   *
   * @dataProvider wildcardsData
   */
  public function testWildcards($name, $method) {
    $list = [
      'a',
      'b',
      'contact*',
      '*.d',
      'e*i',
      'f*de*',
      'x',
    ];
    $configuration = [];
    $configuration['blacklist'] = [];
    $configuration['graylist'] = [];
    $configuration['module'] = [];
    $configuration['theme'] = [];
    $configuration['graylist_dependents'] = TRUE;
    $configuration[$name] = $list;

    // The config manager returns dependent entities for modules and themes.
    $manager = $this
      ->prophesize('Drupal\\Core\\Config\\ConfigManagerInterface');
    $manager
      ->findConfigEntityDependents(Argument::exact('module'), Argument::cetera())
      ->willReturn([]);
    $manager
      ->findConfigEntityDependents(Argument::exact('theme'), Argument::cetera())
      ->willReturn([]);

    // Add a config storage returning some settings for the filtered modules.
    $all_config = array_merge(array_fill_keys(range("a", "z"), []), [
      'contact' => [],
      'contacts' => [],
      'contact.form' => [],
      'form' => [],
      'form.d' => [],
      'form.demo' => [],
      'formed' => [],
      'ei' => [],
      'efi' => [],
      'efghi' => [],
      'efghijk' => [],
      'abcdefghijk' => [],
    ]);
    $manager
      ->getConfigFactory()
      ->willReturn($this
      ->getConfigStorageStub($all_config));
    $expected = [
      'a',
      'b',
      'contact',
      'contact.form',
      'contacts',
      'efghi',
      'efi',
      'ei',
      'form.d',
      'form.demo',
      'x',
    ];
    $manager
      ->findConfigEntityDependents(Argument::exact('config'), Argument::exact($expected))
      ->willReturn([]);
    $manager
      ->findConfigEntityDependents(Argument::exact('config'), Argument::exact([]))
      ->willReturn([]);
    $filter = new SplitFilter($configuration, 'config_split', [], $manager
      ->reveal());
    $actual = $filter
      ->{$method}();
    $this
      ->assertArrayEquals($expected, $actual);
  }

  /**
   * The data for the wildcard test.
   */
  public function wildcardsData() {

    // We need to test the methods separately.
    return [
      [
        'blacklist',
        'getBlacklist',
      ],
      [
        'graylist',
        'getGraylist',
      ],
    ];
  }

  /**
   * Test that the filter reads correctly.
   */
  public function testFilterRead() {

    // Transparent filter.
    $name = $this
      ->randomMachineName();
    $data = (array) $this
      ->getRandomGenerator()
      ->object();
    $filter = $this
      ->getFilter();
    $this
      ->assertEquals($data, $filter
      ->filterRead($name, $data));

    // Filter with a storage that has an alternative.
    $name2 = $this
      ->randomMachineName();
    $data2 = (array) $this
      ->getRandomGenerator()
      ->object();
    $storage = $this
      ->prophesize(StorageInterface::class);
    $storage
      ->read($name)
      ->willReturn(NULL);
    $storage
      ->read($name2)
      ->willReturn($data2);
    $filter = $this
      ->getFilter($storage
      ->reveal());
    $this
      ->assertEquals($data, $filter
      ->filterRead($name, $data));
    $this
      ->assertEquals($data2, $filter
      ->filterRead($name2, $data));

    // Test that extensions are correctly added.
    $extensions = [
      'module' => [
        'config' => 0,
        'user' => 0,
        'views_ui' => 0,
        'menu_link_content' => 1,
        'views' => 10,
      ],
      'theme' => [
        'stable' => 0,
        'classy' => 0,
      ],
    ];
    $modules = [
      'module1' => 0,
      'module2' => 1,
    ];
    $themes = [
      'custom_theme' => 0,
    ];
    $extensions_extra = [
      'module' => [
        'config' => 0,
        'module1' => 0,
        'user' => 0,
        'views_ui' => 0,
        'menu_link_content' => 1,
        'module2' => 1,
        'views' => 10,
      ],
      'theme' => [
        'stable' => 0,
        'classy' => 0,
        'custom_theme' => 0,
      ],
    ];
    $filter = $this
      ->getFilter(NULL, [], $modules, $themes);
    $this
      ->assertEquals($extensions_extra, $filter
      ->filterRead('core.extension', $extensions));
    $this
      ->assertEquals($extensions_extra, $filter
      ->filterRead('core.extension', $extensions_extra));

    // Test with reading from the wrapper storage.
    $filter = $this
      ->getFilter(NULL, [], [
      'none' => 0,
    ], [
      'none' => 0,
    ], [], $name);
    $storage = $this
      ->prophesize(StorageInterface::class);
    $storage
      ->read($name)
      ->willReturn([
      'module' => $modules,
      'theme' => $themes,
    ]);
    $filter
      ->setFilteredStorage($storage
      ->reveal());
    $this
      ->assertEquals($extensions_extra, $filter
      ->filterRead('core.extension', $extensions));
    $this
      ->assertEquals($extensions_extra, $filter
      ->filterRead('core.extension', $extensions_extra));

    // Test with reading from the wrapper storage.
    $filter = $this
      ->getFilter(NULL, [], [
      'none' => 0,
    ], [
      'none' => 0,
    ], [], $name);
    $storage = $this
      ->prophesize(StorageInterface::class);
    $storage
      ->read($name)
      ->willReturn(FALSE);
    $filter
      ->setFilteredStorage($storage
      ->reveal());
    $this
      ->assertEquals($extensions, $filter
      ->filterRead('core.extension', $extensions));
    $this
      ->assertEquals($extensions_extra, $filter
      ->filterRead('core.extension', $extensions_extra));
  }

  /**
   * Test that the filter writes correctly.
   */
  public function testFilterWrite() {

    // Transparent filter.
    $name = $this
      ->randomMachineName();
    $data = (array) $this
      ->getRandomGenerator()
      ->object();
    try {
      $filter = $this
        ->getFilter();
      $filter
        ->filterWrite($name, $data);
      $this
        ->fail('The filter needs a storage.');
    } catch (\InvalidArgumentException $exception) {
      $this
        ->assertTrue(TRUE, 'Exception thrown.');
    }
    $filter = $this
      ->getFilter(new NullStorage());
    $this
      ->assertEquals($data, $filter
      ->filterWrite($name, $data));

    // Filter with a blacklist.
    $name2 = $this
      ->randomMachineName();
    $filter = $this
      ->getFilter(new NullStorage(), [
      $name2,
    ], [], []);
    $this
      ->assertEquals($data, $filter
      ->filterWrite($name, $data));
    $this
      ->assertNull($filter
      ->filterWrite($name2, $data));

    // Filter with a blacklist and a storage.
    $storage = $this
      ->prophesize(StorageInterface::class);
    $storage
      ->write(Argument::cetera())
      ->willReturn(TRUE);
    $storage
      ->exists($name)
      ->willReturn(FALSE);
    $filter = $this
      ->getFilter($storage
      ->reveal(), [
      $name2,
    ], [], []);
    $this
      ->assertEquals($data, $filter
      ->filterWrite($name, $data));
    $this
      ->assertNull($filter
      ->filterWrite($name2, $data));

    // Filter with a gray list and a storage.
    $name3 = $this
      ->randomMachineName();
    $data3 = (array) $this
      ->getRandomGenerator()
      ->object();
    $storage = $this
      ->prophesize(StorageInterface::class);
    $storage
      ->write(Argument::cetera())
      ->willReturn(TRUE);
    $storage
      ->read($name3)
      ->willReturn($data3);
    $storage
      ->exists($name)
      ->willReturn(TRUE);
    $storage
      ->delete($name)
      ->willReturn(TRUE)
      ->shouldBeCalled();
    $storage = $storage
      ->reveal();
    $filter = $this
      ->getFilter($storage, [
      $name2,
    ], [], [], [
      $name3,
    ]);
    $filter
      ->setSourceStorage($storage);
    $this
      ->assertEquals($data, $filter
      ->filterWrite($name, $data));
    $this
      ->assertNull($filter
      ->filterWrite($name2, $data));
    $this
      ->assertEquals($data3, $filter
      ->filterWrite($name3, $data));

    // Filter with graylist and skipping equal data.
    $primary = $this
      ->prophesize(StorageInterface::class);
    $primary
      ->read($name3)
      ->willReturn($data3);
    $primary = $primary
      ->reveal();
    $secondary = $this
      ->prophesize(StorageInterface::class);
    $secondary
      ->exists($name)
      ->willReturn(FALSE);
    $secondary
      ->write($name2, $data)
      ->willReturn(TRUE);
    $secondary
      ->write($name3, $data)
      ->willReturn(TRUE);
    $secondary
      ->exists($name3)
      ->willReturn(TRUE);
    $secondary
      ->delete($name3)
      ->willReturn(TRUE)
      ->shouldBeCalled();
    $secondary = $secondary
      ->reveal();
    $filter = $this
      ->getFilter($secondary, [
      $name2,
    ], [], [], [
      $name3,
    ], 'test', TRUE);
    $filter
      ->setSourceStorage($primary);
    $this
      ->assertEquals($data, $filter
      ->filterWrite($name, $data));
    $this
      ->assertNull($filter
      ->filterWrite($name2, $data));
    $this
      ->assertEquals($data3, $filter
      ->filterWrite($name3, $data));
    $this
      ->assertEquals($data3, $filter
      ->filterWrite($name3, $data3));

    // Test that extensions are correctly removed.
    $extensions = [
      'module' => [
        'config' => 0,
        'user' => 0,
        'views_ui' => 0,
        'menu_link_content' => 1,
        'views' => 10,
      ],
      'theme' => [
        'stable' => 0,
        'classy' => 0,
      ],
    ];
    $modules = [
      'module1' => 0,
      'module2' => 1,
    ];
    $themes = [
      'custom_theme' => 0,
    ];
    $extensions_extra = [
      'module' => [
        'config' => 0,
        'module1' => 0,
        'user' => 0,
        'views_ui' => 0,
        'menu_link_content' => 1,
        'module2' => 1,
        'views' => 10,
      ],
      'theme' => [
        'stable' => 0,
        'classy' => 0,
        'custom_theme' => 0,
      ],
    ];
    $filter = $this
      ->getFilter(new NullStorage(), [], $modules, $themes);
    $this
      ->assertEquals($extensions, $filter
      ->filterWrite('core.extension', $extensions));
    $this
      ->assertEquals($extensions, $filter
      ->filterWrite('core.extension', $extensions_extra));

    // Test that empty config is not written to the split storage.
    $storage = $this
      ->prophesize(StorageInterface::class);
    $storage
      ->write($name2, [])
      ->shouldNotBeCalled();
    $storage
      ->write($name3, [])
      ->shouldNotBeCalled();
    $filter = $this
      ->getFilter($storage
      ->reveal(), [
      $name2,
    ], [], [], [
      $name3,
    ], 'test', TRUE);
    $this
      ->assertNull($filter
      ->filterWrite($name2, []));
    $this
      ->assertNull($filter
      ->filterWrite($name3, []));
  }

  /**
   * Test that the filter checks existence correctly.
   */
  public function testFilterExists() {
    $storage = $this
      ->prophesize(StorageInterface::class);
    $storage
      ->exists('Yes')
      ->willReturn(TRUE);
    $storage
      ->exists('No')
      ->willReturn(FALSE);
    $transparent = $this
      ->getFilter(NULL);
    $filter = $this
      ->getFilter($storage
      ->reveal());
    $this
      ->assertTrue($transparent
      ->filterExists('Yes', TRUE));
    $this
      ->assertTrue($transparent
      ->filterExists('No', TRUE));
    $this
      ->assertFalse($transparent
      ->filterExists('Yes', FALSE));
    $this
      ->assertFalse($transparent
      ->filterExists('No', FALSE));
    $this
      ->assertTrue($filter
      ->filterExists('Yes', TRUE));
    $this
      ->assertTrue($filter
      ->filterExists('No', TRUE));
    $this
      ->assertTrue($filter
      ->filterExists('Yes', FALSE));
    $this
      ->assertFalse($filter
      ->filterExists('No', FALSE));
  }

  /**
   * Test that the filter deletes correctly.
   */
  public function testFilterDelete() {
    $storage = $this
      ->prophesize(StorageInterface::class);
    $storage
      ->exists('Yes')
      ->willReturn(TRUE);
    $storage
      ->delete('Yes')
      ->willReturn(TRUE);
    $transparent = $this
      ->getFilter(NULL);
    $filter = $this
      ->getFilter($storage
      ->reveal());
    $this
      ->assertTrue($transparent
      ->filterDelete('Yes', TRUE));
    $this
      ->assertFalse($transparent
      ->filterDelete('No', FALSE));
    $this
      ->assertTrue($filter
      ->filterDelete('Yes', TRUE));
    $this
      ->assertFalse($filter
      ->filterDelete('No', FALSE));
  }

  /**
   * Test that the filter reads multiple objects correctly.
   */
  public function testFilterReadMultiple() {

    // Set up random config storage.
    $primary = (array) $this
      ->getRandomGenerator()
      ->object(rand(3, 10));
    $secondary = (array) $this
      ->getRandomGenerator()
      ->object(rand(3, 10));
    $merged = array_merge($primary, $secondary);
    $storage = $this
      ->prophesize(StorageInterface::class);
    $storage
      ->readMultiple(Argument::cetera())
      ->willReturn($secondary);
    $transparent = $this
      ->getFilter(NULL);
    $filter = $this
      ->getFilter($storage
      ->reveal());

    // Test listing config.
    $this
      ->assertArrayEquals($primary, $transparent
      ->filterReadMultiple(array_keys($merged), $primary));
    $this
      ->assertArrayEquals($merged, $filter
      ->filterReadMultiple(array_keys($merged), $primary));
  }

  /**
   * Test that the filter lists all correctly.
   */
  public function testFilterListAll() {

    // Set up random config storage.
    $primary = (array) $this
      ->getRandomGenerator()
      ->object(rand(3, 10));
    $secondary = (array) $this
      ->getRandomGenerator()
      ->object(rand(3, 10));
    $merged = array_merge($primary, $secondary);
    $storage = $this
      ->getConfigStorageStub($secondary);
    $transparent = $this
      ->getFilter(NULL);
    $filter = $this
      ->getFilter($storage);

    // Test listing config.
    $this
      ->assertArrayEquals(array_keys($primary), $transparent
      ->filterListAll('', array_keys($primary)));
    $this
      ->assertArrayEquals(array_keys($merged), $filter
      ->filterListAll('', array_keys($primary)));
  }

  /**
   * Test that the filter deletes all correctly.
   */
  public function testFilterDeleteAll() {
    $storage = $this
      ->prophesize(StorageInterface::class);
    $storage
      ->deleteAll('Yes')
      ->willReturn(TRUE);
    $transparent = $this
      ->getFilter(NULL);
    $filter = $this
      ->getFilter($storage
      ->reveal());
    $this
      ->assertTrue($transparent
      ->filterDeleteAll('Yes', TRUE));
    $this
      ->assertFalse($transparent
      ->filterDeleteAll('No', FALSE));
    $this
      ->assertTrue($filter
      ->filterDeleteAll('Yes', TRUE));
    $this
      ->assertFalse($filter
      ->filterDeleteAll('No', FALSE));

    // Test that the storage can throw an exception without affecting execution.
    $failing = $this
      ->prophesize(StorageInterface::class);
    $failing
      ->deleteAll('Yes')
      ->willThrow('\\UnexpectedValueException');
    $filter = $this
      ->getFilter($failing
      ->reveal());
    $this
      ->assertTrue($filter
      ->filterDeleteAll('Yes', TRUE));
  }

  /**
   * Test that the filter creates collections correctly.
   */
  public function testFilterCreateCollection() {
    $collection = $this
      ->randomMachineName();
    $collection_storage = new NullStorage();
    $storage = $this
      ->prophesize(StorageInterface::class);
    $storage
      ->createCollection($collection)
      ->willReturn($collection_storage);
    $transparent = $this
      ->getFilter(NULL);
    $this
      ->assertEquals($transparent, $transparent
      ->filterCreateCollection($collection));
    $filter = $this
      ->getFilter($storage
      ->reveal());
    $new_filter = $filter
      ->filterCreateCollection($collection);

    // Get the protected storage property.
    $internal = new \ReflectionProperty(SplitFilter::class, 'secondaryStorage');
    $internal
      ->setAccessible(TRUE);
    $actual = $internal
      ->getValue($new_filter);
    $this
      ->assertEquals($collection_storage, $actual);
  }

  /**
   * Test that the filter gets collections names correctly.
   */
  public function testFilterGetAllCollectionNames() {
    $collections = array_keys((array) $this
      ->getRandomGenerator()
      ->object(rand(3, 10)));
    $extra = array_keys((array) $this
      ->getRandomGenerator()
      ->object(rand(3, 10)));
    $storage = $this
      ->prophesize(StorageInterface::class);
    $storage
      ->getAllCollectionNames()
      ->willReturn($extra);
    $transparent = $this
      ->getFilter(NULL);
    $filter = $this
      ->getFilter($storage
      ->reveal());
    $this
      ->assertArrayEquals($collections, $transparent
      ->filterGetAllCollectionNames($collections));
    $this
      ->assertArrayEquals(array_merge($collections, $extra), $filter
      ->filterGetAllCollectionNames($collections));
  }

  /**
   * Test that the static create method works and folders contain the htaccess.
   */
  public function testSplitFilterCreate() {
    $name = 'config_split.' . $this
      ->getRandomGenerator()
      ->name();

    // Set the split stream up.
    $folder = vfsStream::setup($name);
    $container = $this
      ->prophesize('Symfony\\Component\\DependencyInjection\\ContainerInterface');
    $container
      ->get('config.manager')
      ->willReturn($this
      ->getConfigManagerMock());
    $container
      ->get('config.factory')
      ->willReturn($this
      ->getConfigFactoryStub([
      $name => [
        'folder' => $folder
          ->url(),
        'module' => [],
        'theme' => [],
        'blacklist' => [],
        'graylist' => [],
      ],
    ]));
    $database = $this
      ->prophesize('Drupal\\Core\\Database\\Connection');
    $container
      ->get('database')
      ->willReturn($database
      ->reveal());
    $configuration = [
      'config_name' => $name,
    ];
    $filter = SplitFilter::create($container
      ->reveal(), $configuration, $this
      ->getRandomGenerator()
      ->name(), []);
    $this
      ->assertTrue($folder
      ->hasChild('.htaccess'), 'htaccess written to split folder.');
    $folder
      ->addChild(new vfsStreamFile($name . '.' . FileStorage::getFileExtension()));
    $this
      ->assertTrue($filter
      ->filterExists($name, FALSE), 'Assert filename');

    // Test split with db storage.
    $name = 'config_split.' . $this
      ->getRandomGenerator()
      ->name();
    $container = $this
      ->prophesize('Symfony\\Component\\DependencyInjection\\ContainerInterface');
    $container
      ->get('config.manager')
      ->willReturn($this
      ->getConfigManagerMock());
    $container
      ->get('config.factory')
      ->willReturn($this
      ->getConfigFactoryStub([
      $name => [
        'folder' => '',
        'module' => [],
        'theme' => [],
        'blacklist' => [],
        'graylist' => [],
      ],
    ]));
    $database = $this
      ->prophesize('Drupal\\Core\\Database\\Connection')
      ->reveal();
    $container
      ->get('database')
      ->willReturn($database);
    $configuration = [
      'config_name' => $name,
    ];
    $filter = SplitFilter::create($container
      ->reveal(), $configuration, $this
      ->getRandomGenerator()
      ->name(), []);

    // Get the protected secondaryStorage property.
    $storage = new \ReflectionProperty(SplitFilter::class, 'secondaryStorage');
    $storage
      ->setAccessible(TRUE);
    $secondary = $storage
      ->getValue($filter);
    $this
      ->assertInstanceOf(DatabaseStorage::class, $secondary);
  }

  /**
   * Returns a SplitFilter that can be used to test its behaviour.
   *
   * @param \Drupal\Core\Config\StorageInterface|null $storage
   *   The Storage interface the filter can use as its alternative storage.
   * @param string[] $blacklist
   *   The blacklisted configuration that is filtered out.
   * @param array $modules
   *   The blacklisted modules that are removed from the core.extensions.
   * @param array $themes
   *   The blacklisted themes that are removed from the core.extensions.
   * @param string[] $graylist
   *   The graylisted configuration that is filtered out.
   * @param string $name
   *   The name of the prophesied config object.
   * @param bool $skip_equal
   *   The flag to skip equal config in graylist exports.
   *
   * @return \Drupal\config_split\Plugin\ConfigFilter\SplitFilter
   *   The filter to test.
   */
  protected function getFilter(StorageInterface $storage = NULL, array $blacklist = [], array $modules = [], array $themes = [], array $graylist = [], $name = 'config_split.config_split.test', $skip_equal = FALSE) {
    $configuration = [];
    $configuration['blacklist'] = $blacklist;
    $configuration['graylist'] = $graylist;
    $configuration['graylist_dependents'] = TRUE;
    $configuration['graylist_skip_equal'] = $skip_equal;
    $configuration['module'] = $modules;
    $configuration['theme'] = $themes;
    $configuration['config_name'] = $name;

    // Return a new filter that behaves as intended.
    return new SplitFilter($configuration, 'config_split', [], $this
      ->getConfigManagerMock($blacklist, $graylist, $modules, $themes), $storage);
  }

  /**
   * Gets a mocked version of the config manager.
   *
   * @param array $blacklist
   *   The config names to blacklist.
   * @param array $graylist
   *   The config names to graylist.
   * @param array $modules
   *   The array of modules.
   * @param array $themes
   *   The array of themes.
   *
   * @return \Drupal\Core\Config\ConfigManagerInterface
   *   The mocked config manager.
   */
  protected function getConfigManagerMock(array $blacklist = [], array $graylist = [], array $modules = [], array $themes = []) {

    // The manager returns nothing but allows the filter to set up correctly.
    // This means that the blacklist is not enhanced but only the one passed
    // as an argument is used.
    $manager = $this
      ->prophesize('Drupal\\Core\\Config\\ConfigManagerInterface');
    $manager
      ->findConfigEntityDependents(Argument::cetera())
      ->willReturn([]);

    // The config factory should return config names for at least all
    // blacklisted and gray listed configuration.
    $all_config = array_fill_keys(array_merge($blacklist, $graylist, array_keys($modules), array_keys($themes)), []);
    $manager
      ->getConfigFactory()
      ->willReturn($this
      ->getConfigStorageStub($all_config));
    return $manager
      ->reveal();
  }

}

Classes

Namesort descending Description
SplitFilterTest Test filter plugin.