View source
<?php
namespace Drupal\Tests\feeds_tamper\Unit\EventSubscriber;
use Drupal\feeds\Event\ParseEvent;
use Drupal\feeds\Feeds\Item\DynamicItem;
use Drupal\feeds\Result\FetcherResultInterface;
use Drupal\feeds\Result\ParserResult;
use Drupal\feeds_tamper\Adapter\TamperableFeedItemAdapter;
use Drupal\feeds_tamper\EventSubscriber\FeedsSubscriber;
use Drupal\feeds_tamper\FeedTypeTamperManagerInterface;
use Drupal\feeds_tamper\FeedTypeTamperMetaInterface;
use Drupal\tamper\Exception\SkipTamperDataException;
use Drupal\tamper\Exception\SkipTamperItemException;
use Drupal\tamper\TamperInterface;
use Drupal\Tests\feeds_tamper\Unit\FeedsTamperTestCase;
use Prophecy\Argument;
class FeedsSubscriberTest extends FeedsTamperTestCase {
protected $subscriber;
protected $event;
protected $tamperMeta;
public function setUp() {
parent::setUp();
$this->event = new ParseEvent($this
->getMockFeed(), $this
->createMock(FetcherResultInterface::class));
$this->event
->setParserResult(new ParserResult());
$this->tamperMeta = $this
->createMock(FeedTypeTamperMetaInterface::class);
$tamper_manager = $this
->createMock(FeedTypeTamperManagerInterface::class);
$tamper_manager
->expects($this
->any())
->method('getTamperMeta')
->will($this
->returnValue($this->tamperMeta));
$this->subscriber = new FeedsSubscriber($tamper_manager);
}
protected function createTamperMock($return_value = NULL) {
$tamper = $this
->createMock(TamperInterface::class);
$tamper
->expects($this
->any())
->method('tamper')
->will($this
->returnValue($return_value));
return $tamper;
}
public function testAfterParse() {
$tamper = $this
->createMock(TamperInterface::class);
$tamper
->expects($this
->any())
->method('tamper')
->will($this
->returnValue('Foo'));
$this->tamperMeta
->expects($this
->once())
->method('getTampersGroupedBySource')
->will($this
->returnValue([
'alpha' => [
$this
->createTamperMock('Foo'),
],
]));
$item = new DynamicItem();
$item
->set('alpha', 'Bar');
$this->event
->getParserResult()
->addItem($item);
$this->subscriber
->afterParse($this->event);
$this
->assertEquals('Foo', $item
->get('alpha'));
}
public function testAfterParseWithNoItems() {
$this->tamperMeta
->expects($this
->once())
->method('getTampersGroupedBySource')
->will($this
->returnValue([
'alpha' => [
$this
->createTamperMock('Foo'),
],
]));
$this->subscriber
->afterParse($this->event);
}
public function testAfterParseWithEmptyArray() {
$tamper = $this
->createMock(TamperInterface::class);
$tamper
->expects($this
->any())
->method('tamper')
->will($this
->returnValue('Foo'));
$this->tamperMeta
->expects($this
->once())
->method('getTampersGroupedBySource')
->will($this
->returnValue([
'alpha' => [
$this
->createTamperMock('Foo'),
],
]));
$item = new DynamicItem();
$item
->set('alpha', []);
$this->event
->getParserResult()
->addItem($item);
$this->subscriber
->afterParse($this->event);
$this
->assertEquals('Foo', $item
->get('alpha'));
}
public function testAfterParseWithNoTampers() {
$this->tamperMeta
->expects($this
->once())
->method('getTampersGroupedBySource')
->will($this
->returnValue([]));
$item = new DynamicItem();
$item
->set('alpha', 'Bar');
$this->event
->getParserResult()
->addItem($item);
$this->subscriber
->afterParse($this->event);
$this
->assertEquals('Bar', $item
->get('alpha'));
}
public function testAfterParseWithMultiValueTampers() {
$tamper1 = $this
->prophesize(TamperInterface::class);
$tamper1
->tamper('Bar', Argument::type(TamperableFeedItemAdapter::class))
->willReturn([
'Bar',
'Bar',
]);
$tamper1
->getPluginDefinition()
->willReturn([
'handle_multiples' => FALSE,
]);
$tamper1
->multiple()
->willReturn(TRUE);
$tamper1 = $tamper1
->reveal();
$tamper2 = $this
->prophesize(TamperInterface::class);
$tamper2
->tamper('Bar', Argument::type(TamperableFeedItemAdapter::class))
->willReturn('Foo');
$tamper2
->getPluginDefinition()
->willReturn([
'handle_multiples' => FALSE,
]);
$tamper2
->multiple()
->willReturn(FALSE);
$tamper2 = $tamper2
->reveal();
$tamper3 = $this
->prophesize(TamperInterface::class);
$tamper3
->tamper('Foo', Argument::type(TamperableFeedItemAdapter::class))
->willReturn('FooFoo');
$tamper3
->getPluginDefinition()
->willReturn([
'handle_multiples' => FALSE,
]);
$tamper3
->multiple()
->willReturn(FALSE);
$tamper3 = $tamper3
->reveal();
$this->tamperMeta
->expects($this
->once())
->method('getTampersGroupedBySource')
->will($this
->returnValue([
'alpha' => [
$tamper1,
$tamper2,
$tamper3,
],
]));
$item = new DynamicItem();
$item
->set('alpha', 'Bar');
$this->event
->getParserResult()
->addItem($item);
$this->subscriber
->afterParse($this->event);
$this
->assertEquals([
'FooFoo',
'FooFoo',
], $item
->get('alpha'));
}
public function testAfterParseWithTamperItem() {
$tamper = $this
->createMock(TamperInterface::class);
$tamper
->expects($this
->once())
->method('tamper')
->will($this
->returnCallback([
$this,
'callbackWithTamperItem',
]));
$this->tamperMeta
->expects($this
->once())
->method('getTampersGroupedBySource')
->will($this
->returnValue([
'alpha' => [
$tamper,
],
]));
$item = new DynamicItem();
$item
->set('alpha', 'Foo');
$item
->set('beta', 'Bar');
$item
->set('gamma', 'Qux');
$this->event
->getParserResult()
->addItem($item);
$this->subscriber
->afterParse($this->event);
$this
->assertEquals('Fooing', $item
->get('alpha'));
$this
->assertEquals('Baring', $item
->get('beta'));
$this
->assertEquals('Quxing', $item
->get('gamma'));
}
public function callbackWithTamperItem($data, TamperableFeedItemAdapter $item) {
foreach ($item
->getSource() as $key => $value) {
$item
->setSourceProperty($key, $value . 'ing');
}
return $data . 'ing';
}
public function testAfterParseWithSkippingItem() {
$tamper = $this
->createMock(TamperInterface::class);
$tamper
->expects($this
->exactly(2))
->method('tamper')
->will($this
->returnCallback([
$this,
'callbackSkipItem',
]));
$this->tamperMeta
->expects($this
->once())
->method('getTampersGroupedBySource')
->will($this
->returnValue([
'alpha' => [
$tamper,
],
]));
$item1 = new DynamicItem();
$item1
->set('alpha', 'Foo');
$this->event
->getParserResult()
->addItem($item1);
$item2 = new DynamicItem();
$item2
->set('alpha', 'Bar');
$this->event
->getParserResult()
->addItem($item2);
$this->subscriber
->afterParse($this->event);
$this
->assertEquals(1, $this->event
->getParserResult()
->count());
$this
->assertSame($item2, $this->event
->getParserResult()
->offsetGet(0));
}
public function callbackSkipItem($data, TamperableFeedItemAdapter $item) {
if ($data == 'Foo') {
throw new SkipTamperItemException();
}
}
public function testAfterParseWithSkippingData() {
$tamper1 = $this
->createMock(TamperInterface::class);
$tamper1
->expects($this
->exactly(2))
->method('tamper')
->will($this
->returnCallback([
$this,
'callbackSkipData',
]));
$tamper2 = $this
->createMock(TamperInterface::class);
$tamper2
->expects($this
->once())
->method('tamper')
->will($this
->returnValue('Qux'));
$tamper3 = $this
->createMock(TamperInterface::class);
$tamper3
->expects($this
->exactly(2))
->method('tamper')
->will($this
->returnValue('Baz'));
$this->tamperMeta
->expects($this
->once())
->method('getTampersGroupedBySource')
->will($this
->returnValue([
'alpha' => [
$tamper1,
$tamper2,
],
'beta' => [
$tamper3,
],
]));
$item1 = new DynamicItem();
$item1
->set('alpha', 'Foo');
$item1
->set('beta', 'Foo');
$this->event
->getParserResult()
->addItem($item1);
$item2 = new DynamicItem();
$item2
->set('alpha', 'Bar');
$item2
->set('beta', 'Bar');
$this->event
->getParserResult()
->addItem($item2);
$this->subscriber
->afterParse($this->event);
$this
->assertEquals(2, $this->event
->getParserResult()
->count());
$this
->assertNull($item1
->get('alpha'));
$this
->assertEquals($item1
->get('beta'), 'Baz');
$this
->assertEquals($item2
->get('alpha'), 'Qux');
$this
->assertEquals($item2
->get('beta'), 'Baz');
}
public function callbackSkipData($data, TamperableFeedItemAdapter $item) {
if ($data == 'Foo') {
throw new SkipTamperDataException();
}
}
}