/**
* @test
*/
function it_can_be_converted_to_array_and_back()
{
$processingTypes = ProcessingTypes::support([String::prototype(), Integer::prototype()]);
$definition = $processingTypes->toArray();
$copiedProcessingTypes = ProcessingTypes::fromArray($definition);
$this->assertTrue($copiedProcessingTypes->isSupported(String::prototype()));
$this->assertTrue($copiedProcessingTypes->isSupported(Integer::prototype()));
$this->assertFalse($copiedProcessingTypes->isSupported(Float::prototype()));
$allProcessingTypes = ProcessingTypes::supportAll();
$definition = $allProcessingTypes->toArray();
$copiedProcessingTypes = ProcessingTypes::fromArray($definition);
$this->assertTrue($copiedProcessingTypes->isSupported(Float::prototype()));
}
/**
* @param Message $message
* @return bool
*/
public function canHandleMessage(Message $message)
{
$this->lastValidationError = null;
if (!$this->canHandleMessageType($message->messageType())) {
$this->lastValidationError = sprintf("Message type %s is not supported.", $message->messageType());
return false;
}
if ($message->processingMetadata()->shouldCollectionBeSplitIntoChunks()) {
if (!$this->processingMetadata->canHandleChunks()) {
$this->lastValidationError = "Unable to handle chunks.";
return false;
}
}
if (!$this->supportedProcessingTypes->isSupported($message->processingType())) {
$this->lastValidationError = sprintf("Processing type %s is not supported. Supported types are: %s", $message->processingType()->of(), implode(", ", $this->supportedProcessingTypes->toArray()['processing_types']));
return false;
}
return true;
}
/**
* @test
*/
function it_installs_a_message_handler()
{
$messageHandler = ProcessingNode::initializeAs(NodeName::defaultName())->installMessageHandler(MessageHandlerId::generate(), 'Article Exporter', HandlerType::connector(), DataDirection::source(), ProcessingTypes::support([ArticleCollection::prototype()]), ProcessingMetadata::noData(), 'sqlconnector-pm-metadata', 'glyphicon-hdd', 'glyphicon', ArticleCollection::prototype(), ProcessingId::fromString('sqlconnector:::example'));
$this->assertInstanceOf(MessageHandler::class, $messageHandler);
}
/**
* @param bool $singleItemMode
* @return MessageHandler
*/
protected function getArticleImporterMessageHandler($singleItemMode = false)
{
$supportedProcessingType = $singleItemMode ? Article::prototype() : ArticleCollection::prototype();
return MessageHandler::fromDefinition(MessageHandlerId::generate(), 'Article Importer', NodeName::defaultName(), MessageHandler\HandlerType::connector(), MessageHandler\DataDirection::target(), MessageHandler\ProcessingTypes::support([$supportedProcessingType]), ProcessingMetadata::fromArray(['chunk_support' => true]), 'sqlconnector-pm-metadata', 'glyphicon-hdd', 'glyphicon');
}
/**
* @return ProcessingTypes
*/
public function supportedProcessingTypes()
{
$supportedProcessingTypes = $this->payload['supported_processing_types'];
if (is_string($supportedProcessingTypes) && $supportedProcessingTypes === ProcessingTypes::SUPPORT_ALL) {
$supportedProcessingTypes = ProcessingTypes::supportAll();
} else {
$supportedProcessingTypes = ProcessingTypes::support($supportedProcessingTypes);
}
return $supportedProcessingTypes;
}
/**
* @param $dataDirection
* @param null|string $handlerType
* @param null|array $metadata
* @return MessageHandler
*/
private function getMessageHandler($dataDirection, $handlerType = null, array $metadata = null)
{
if (!is_null($handlerType)) {
$handlerType = MessageHandler\HandlerType::fromString($handlerType);
} else {
$handlerType = MessageHandler\HandlerType::connector();
}
if (!is_null($metadata)) {
$metadata = ProcessingMetadata::fromArray($metadata);
} else {
$metadata = ProcessingMetadata::noData();
}
return MessageHandler::fromDefinition(MessageHandlerId::generate(), 'Article Export', NodeName::defaultName(), $handlerType, MessageHandler\DataDirection::fromString($dataDirection), MessageHandler\ProcessingTypes::support([ArticleCollection::prototype(), Article::prototype()]), $metadata, 'sqlconnector-pm-metadata', 'glyphicon-hdd', 'glyphicon', Article::prototype(), MessageHandler\ProcessingId::fromString('sqlconnector:::example'));
}
/**
* @return ProcessingTypes
*/
public function supportedProcessingTypes()
{
if (is_null($this->supportedProcessingTypes)) {
$this->supportedProcessingTypes = ProcessingTypes::fromArray($this->payload['supported_processing_types']);
}
return $this->supportedProcessingTypes;
}
