class FeedRefreshTest in Feeds 8.3

@coversDefaultClass \Drupal\feeds\Plugin\QueueWorker\FeedRefresh @group feeds

Hierarchy

class \Drupal\Tests\UnitTestCase extends \PHPUnit\Framework\TestCase uses PhpunitCompatibilityTrait
- class \Drupal\Tests\feeds\Unit\FeedsUnitTestCase uses FeedsMockingTrait, FeedsReflectionTrait
  - class \Drupal\Tests\feeds\Unit\Plugin\QueueWorker\FeedRefreshTest

Expanded class hierarchy of FeedRefreshTest

File

tests/src/Unit/Plugin/QueueWorker/FeedRefreshTest.php, line 30

Namespace

Drupal\Tests\feeds\Unit\Plugin\QueueWorker

View source

class FeedRefreshTest extends FeedsUnitTestCase {

  /**
   * The event dispatcher.
   *
   * @var \Symfony\Component\EventDispatcher\EventDispatcher
   */
  protected $dispatcher;

  /**
   * The QueueWorker plugin.
   *
   * @var Drupal\feeds\Plugin\QueueWorker\FeedRefresh
   */
  protected $plugin;

  /**
   * The feed.
   *
   * @var Drupal\feeds\FeedInterface
   */
  protected $feed;

  /**
   * {@inheritdoc}
   */
  public function setUp() {
    parent::setUp();
    $this->dispatcher = new EventDispatcher();
    $queue_factory = $this
      ->createMock(QueueFactory::class, [], [], '', FALSE);
    $queue_factory
      ->expects($this
      ->any())
      ->method('get')
      ->with('feeds_feed_refresh:')
      ->will($this
      ->returnValue($this
      ->createMock(QueueInterface::class)));
    $entity_type_manager = $this
      ->createMock(EntityTypeManagerInterface::class);
    $messenger = $this
      ->createMock(MessengerInterface::class);
    $executable = new FeedsQueueExecutable($entity_type_manager, $this->dispatcher, $this
      ->getMockedAccountSwitcher(), $messenger, $queue_factory);
    $executable
      ->setStringTranslation($this
      ->getStringTranslationStub());
    $this->plugin = $this
      ->getMockBuilder(FeedRefresh::class)
      ->setMethods([
      'feedExists',
      'getExecutable',
    ])
      ->setConstructorArgs([
      [],
      'feeds_feed_refresh',
      [],
      $queue_factory,
      $this->dispatcher,
      $this
        ->getMockedAccountSwitcher(),
      $entity_type_manager,
    ])
      ->getMock();
    $this->plugin
      ->expects($this
      ->any())
      ->method('feedExists')
      ->will($this
      ->returnValue(TRUE));
    $this->plugin
      ->expects($this
      ->any())
      ->method('getExecutable')
      ->will($this
      ->returnValue($executable));
    $connection = $this
      ->prophesize(Connection::class);
    $connection
      ->query(Argument::type('string'), Argument::type('array'))
      ->willReturn($this
      ->createMock(StatementInterface::class));
    $this->feed = $this
      ->getMockFeed();
    $this->feed
      ->expects($this
      ->any())
      ->method('getState')
      ->with(StateInterface::CLEAN)
      ->will($this
      ->returnValue(new CleanState(1, $connection
      ->reveal())));
  }

  /**
   * Tests initiating an import.
   */
  public function testBeginStage() {
    $this->plugin
      ->processItem(NULL);
    $this->plugin
      ->processItem([
      $this->feed,
      FeedsExecutableInterface::BEGIN,
      [],
    ]);
  }

  /**
   * Tests that an import cannot start when the feed is locked.
   */
  public function testLockException() {
    $this->feed
      ->expects($this
      ->once())
      ->method('lock')
      ->will($this
      ->throwException(new LockException()));
    $this->plugin
      ->processItem([
      $this->feed,
      FeedsExecutableInterface::BEGIN,
      [],
    ]);
  }

  /**
   * Tests that a fetch event is dispatched when initiating an import.
   */
  public function testExceptionOnFetchEvent() {
    $this->dispatcher
      ->addListener(FeedsEvents::FETCH, function ($parse_event) {
      throw new RuntimeException();
    });
    $this
      ->expectException(RuntimeException::class);
    $this->plugin
      ->processItem([
      $this->feed,
      FeedsExecutableInterface::FETCH,
      [],
    ]);
  }

  /**
   * Tests the parse stage of an import.
   */
  public function testParseStage() {
    $this->dispatcher
      ->addListener(FeedsEvents::PARSE, function ($parse_event) {
      $parser_result = new ParserResult();
      $parser_result
        ->addItem(new DynamicItem());
      $parse_event
        ->setParserResult($parser_result);
    });
    $fetcher_result = new FetcherResult('');
    $this->plugin
      ->processItem([
      $this->feed,
      FeedsExecutableInterface::PARSE,
      [
        'fetcher_result' => $fetcher_result,
      ],
    ]);
  }

  /**
   * Tests dispatching a parse event when running a queue task.
   *
   * When running a queue task at the parse stage, a parse event should get
   * dispatched.
   */
  public function testExceptionOnParseEvent() {
    $this->dispatcher
      ->addListener(FeedsEvents::PARSE, function ($parse_event) {
      throw new RuntimeException();
    });
    $this
      ->expectException(RuntimeException::class);
    $this->plugin
      ->processItem([
      $this->feed,
      FeedsExecutableInterface::PARSE,
      [
        'fetcher_result' => new FetcherResult(''),
      ],
    ]);
  }

  /**
   * Tests the process stage of an import.
   */
  public function testProcessStage() {
    $this->plugin
      ->processItem([
      $this->feed,
      FeedsExecutableInterface::PROCESS,
      [
        'item' => new DynamicItem(),
      ],
    ]);
  }

  /**
   * Tests dispatching a process event when running a queue task.
   *
   * When running a queue task at the process stage, a process event should get
   * dispatched.
   */
  public function testExceptionOnProcessEvent() {
    $this->dispatcher
      ->addListener(FeedsEvents::PROCESS, function ($parse_event) {
      throw new RuntimeException();
    });
    $this
      ->expectException(RuntimeException::class);
    $this->plugin
      ->processItem([
      $this->feed,
      FeedsExecutableInterface::PROCESS,
      [
        'item' => new DynamicItem(),
      ],
    ]);
  }

  /**
   * Tests the final stage of an import.
   */
  public function testFinalPass() {
    $this->plugin
      ->processItem([
      $this->feed,
      FeedsExecutableInterface::FINISH,
      [
        'fetcher_result' => new FetcherResult(''),
      ],
    ]);
    $this->feed
      ->expects($this
      ->exactly(2))
      ->method('progressParsing')
      ->will($this
      ->returnValue(StateInterface::BATCH_COMPLETE));
    $this->plugin
      ->processItem([
      $this->feed,
      FeedsExecutableInterface::FINISH,
      [
        'fetcher_result' => new FetcherResult(''),
      ],
    ]);
    $this->feed
      ->expects($this
      ->once())
      ->method('progressFetching')
      ->will($this
      ->returnValue(StateInterface::BATCH_COMPLETE));
    $this->plugin
      ->processItem([
      $this->feed,
      FeedsExecutableInterface::FINISH,
      [
        'fetcher_result' => new FetcherResult(''),
      ],
    ]);
  }

}

Members

Name	Modifiers	Type	Description	Overrides
FeedRefreshTest::$dispatcher	protected	property	The event dispatcher.
FeedRefreshTest::$feed	protected	property	The feed.
FeedRefreshTest::$plugin	protected	property	The QueueWorker plugin.
FeedRefreshTest::setUp	public	function	Overrides FeedsUnitTestCase::setUp
FeedRefreshTest::testBeginStage	public	function	Tests initiating an import.
FeedRefreshTest::testExceptionOnFetchEvent	public	function	Tests that a fetch event is dispatched when initiating an import.
FeedRefreshTest::testExceptionOnParseEvent	public	function	Tests dispatching a parse event when running a queue task.
FeedRefreshTest::testExceptionOnProcessEvent	public	function	Tests dispatching a process event when running a queue task.
FeedRefreshTest::testFinalPass	public	function	Tests the final stage of an import.
FeedRefreshTest::testLockException	public	function	Tests that an import cannot start when the feed is locked.
FeedRefreshTest::testParseStage	public	function	Tests the parse stage of an import.
FeedRefreshTest::testProcessStage	public	function	Tests the process stage of an import.
FeedsMockingTrait::getMockAccount	protected	function	Mocks an account object.
FeedsMockingTrait::getMockedAccountSwitcher	protected	function	Returns a mocked AccountSwitcher object.
FeedsMockingTrait::getMockFeed	protected	function	Returns a mocked feed entity.
FeedsMockingTrait::getMockFeedType	protected	function	Returns a mocked feed type entity.
FeedsMockingTrait::getMockFieldDefinition	protected	function	Mocks a field definition.	1
FeedsMockingTrait::getMockFileSystem	protected	function	Mocks the file system.
FeedsReflectionTrait::callProtectedMethod	protected	function	Calls a protected method on the given object.
FeedsReflectionTrait::getMethod	protected	function	Gets a ReflectionMethod for a class method.
FeedsReflectionTrait::getProtectedClosure	protected	function	Returns a dynamically created closure for the object's method.
FeedsReflectionTrait::setProtectedProperty	protected	function	Sets a protected property.
FeedsUnitTestCase::absolutePath	protected	function	Returns the absolute directory path of the Feeds module.
FeedsUnitTestCase::defineConstants	protected	function	Defines stub constants.
FeedsUnitTestCase::getMockStreamWrapperManager	protected	function	Returns a mock stream wrapper manager.
FeedsUnitTestCase::resourcesPath	protected	function	Returns the absolute directory path of the resources folder.
PhpunitCompatibilityTrait::getMock Deprecated	public	function	Returns a mock object for the specified class using the available method.
PhpunitCompatibilityTrait::setExpectedException Deprecated	public	function	Compatibility layer for PHPUnit 6 to support PHPUnit 4 code.
UnitTestCase::$randomGenerator	protected	property	The random generator.
UnitTestCase::$root	protected	property	The app root.	1
UnitTestCase::assertArrayEquals	protected	function	Asserts if two arrays are equal by sorting them first.
UnitTestCase::getBlockMockWithMachineName Deprecated	protected	function	Mocks a block with a block plugin.	1
UnitTestCase::getClassResolverStub	protected	function	Returns a stub class resolver.
UnitTestCase::getConfigFactoryStub	public	function	Returns a stub config factory that behaves according to the passed array.
UnitTestCase::getConfigStorageStub	public	function	Returns a stub config storage that returns the supplied configuration.
UnitTestCase::getContainerWithCacheTagsInvalidator	protected	function	Sets up a container with a cache tags invalidator.
UnitTestCase::getRandomGenerator	protected	function	Gets the random generator for the utility methods.
UnitTestCase::getStringTranslationStub	public	function	Returns a stub translation manager that just returns the passed string.
UnitTestCase::randomMachineName	public	function	Generates a unique random string containing letters and numbers.

You are here

class FeedRefreshTest in Feeds 8.3

Hierarchy

File

Namespace

Members

API Navigation