/**
* @dataProvider siteLinkProvider
*/
public function testSiteLinkSerializationRoundtrips(SiteLink $siteLink)
{
$serializerFactory = new SerializerFactory(new DataValueSerializer());
$deserializerFactory = new DeserializerFactory(new DataValueDeserializer(), new BasicEntityIdParser());
$serialization = $serializerFactory->newSiteLinkSerializer()->serialize($siteLink);
$newSiteLink = $deserializerFactory->newSiteLinkDeserializer()->deserialize($serialization);
$this->assertEquals($siteLink, $newSiteLink);
}
/**
* @dataProvider entityProvider
*/
public function testEntitySerializationRoundtrips(Entity $entity)
{
$serializerFactory = new SerializerFactory(new DataValueSerializer());
$deserializerFactory = new DeserializerFactory(new DataValueDeserializer(), new BasicEntityIdParser());
$serialization = $serializerFactory->newEntitySerializer()->serialize($entity);
$newEntity = $deserializerFactory->newEntityDeserializer()->deserialize($serialization);
$this->assertTrue($entity->equals($newEntity));
}
/**
* @dataProvider snakListProvider
*/
public function testSnakSerializationRoundtrips(SnakList $snaks)
{
$serializerFactory = new SerializerFactory(new DataValueSerializer());
$deserializerFactory = new DeserializerFactory(new DataValueDeserializer(), new BasicEntityIdParser());
$serialization = $serializerFactory->newSnakListSerializer()->serialize($snaks);
$newSnaks = $deserializerFactory->newSnakListDeserializer()->deserialize($serialization);
$this->assertEquals($snaks, $newSnaks);
}
/**
* @dataProvider snaksProvider
*/
public function testSnakSerializationRoundtrips(Statement $statement)
{
$serializerFactory = new SerializerFactory(new DataValueSerializer());
$deserializerFactory = new DeserializerFactory(new DataValueDeserializer(), new BasicEntityIdParser());
$serialization = $serializerFactory->newStatementSerializer()->serialize($statement);
$newStatement = $deserializerFactory->newStatementDeserializer()->deserialize($serialization);
$this->assertEquals($statement->getHash(), $newStatement->getHash());
}
/**
* @dataProvider referencesProvider
*/
public function testReferenceSerializationRoundtrips(ReferenceList $references)
{
$serializerFactory = new SerializerFactory(new DataValueSerializer());
$deserializerFactory = new DeserializerFactory(new DataValueDeserializer(), new BasicEntityIdParser());
$serialization = $serializerFactory->newReferencesSerializer()->serialize($references);
$newReferences = $deserializerFactory->newReferencesDeserializer()->deserialize($serialization);
$this->assertReferenceListEquals($references, $newReferences);
}
/**
* @dataProvider referenceProvider
*/
public function testSnakSerializationRoundtrips(Reference $reference)
{
$serializerFactory = new SerializerFactory(new DataValueSerializer());
$deserializerFactory = new DeserializerFactory(new DataValueDeserializer(), new BasicEntityIdParser());
$serialization = $serializerFactory->newReferenceSerializer()->serialize($reference);
$newReference = $deserializerFactory->newReferenceDeserializer()->deserialize($serialization);
$this->assertTrue($reference->equals($newReference));
}
/**
* Create concrete dumper instance
* @param resource $output
* @return DumpGenerator
*/
protected function createDumper($output)
{
$serializerOptions = SerializerFactory::OPTION_SERIALIZE_MAIN_SNAKS_WITHOUT_HASH + SerializerFactory::OPTION_SERIALIZE_REFERENCE_SNAKS_WITHOUT_HASH;
$serializerFactory = new SerializerFactory(new DataValueSerializer(), $serializerOptions);
$entitySerializer = $serializerFactory->newEntitySerializer();
$dataTypeLookup = $this->propertyDatatypeLookup;
$dumper = new JsonDumpGenerator($output, $this->entityLookup, $entitySerializer, $this->entityPrefetcher, $dataTypeLookup);
$dumper->setUseSnippets((bool) $this->getOption('snippet', false));
return $dumper;
}
/**
* @dataProvider rankProvider
*/
public function testRankSerialization($rank)
{
$statement = new Statement(new PropertyNoValueSnak(new PropertyId('P42')));
$statement->setRank($rank);
$factory = new SerializerFactory(new DataValueSerializer());
$statementSerializer = $factory->newStatementSerializer();
$serialization = $statementSerializer->serialize($statement);
$rankSerializer = new StatementRankSerializer();
$this->assertEquals($rank, $rankSerializer->deserialize($serialization['rank']), 'Roundtrip between rank serialization and unserialization 1');
$this->assertEquals($serialization['rank'], $rankSerializer->serialize($rank), 'Roundtrip between rank serialization and unserialization 2');
}
/**
* @param Entity $entity
*
* @return string
*/
private function getSerializedEntity(Entity $entity)
{
$serializer = $this->serializerFactory->newEntitySerializer();
$serialization = $serializer->serialize($entity);
// Remove empty parts of the serialization (Added when Lib Serializers were removed)
// We could allow parts if we are sure it would not break anything
foreach ($serialization as $key => $serializationPart) {
if (is_array($serializationPart) && empty($serializationPart)) {
unset($serialization[$key]);
}
}
return $serialization;
}
/**
* @see ResultBuilder::addEntityRevision
*
* @param EntityDocument $entity
*
* @throws SerializationException
* @return array
*/
public function serialize($entity)
{
$serializerOptions = SerializerFactory::OPTION_SERIALIZE_MAIN_SNAKS_WITHOUT_HASH + SerializerFactory::OPTION_SERIALIZE_REFERENCE_SNAKS_WITHOUT_HASH;
$serializerFactory = new SerializerFactory(new DataValueSerializer(), $serializerOptions);
$entitySerializer = $serializerFactory->newEntitySerializer();
$serialization = $entitySerializer->serialize($entity);
if (!empty($this->fallbackChains)) {
$serialization = $this->addEntitySerializationFallbackInfo($serialization);
}
$serialization = $this->injectEntitySerializationWithDataTypes($serialization);
$serialization = $this->filterEntitySerializationUsingLangCodes($serialization);
return $this->omitEmptyArrays($serialization);
}
/**
* Serializes a Reference object (if not serialized already).
*
* @param Reference|array $reference
* @return array
*/
protected function serializeReference($reference)
{
if ($reference instanceof Reference) {
$reference = $this->serializerFactory->newReferenceSerializer()->serialize($reference);
}
return $reference;
}
private function getJsonDumperWithExceptionHandler(array $ids, Exception $ex)
{
$entityLookup = $this->getEntityLookupThrows($ex);
$out = fopen('php://output', 'w');
$serializer = $this->serializerFactory->newEntitySerializer();
$jsonDumper = new JsonDumpGenerator($out, $entityLookup, $serializer, new NullEntityPrefetcher(), $this->getMockPropertyDataTypeLookup());
$exceptionHandler = $this->getMock('Wikibase\\Lib\\Reporting\\ExceptionHandler');
$exceptionHandler->expects($this->exactly(count($ids)))->method('handleException');
$jsonDumper->setExceptionHandler($exceptionHandler);
return $jsonDumper;
}
/**
* Get serialized reference and add it to result
*
* @param Reference $reference
*
* @since 0.5
*/
public function addReference(Reference $reference)
{
$serializer = $this->serializerFactory->newReferenceSerializer();
//TODO: this is currently only used to add a Reference as the top level structure,
// with a null path and a fixed name. Would be nice to also allow references
// to be added to a list, using a path and a id key or index.
$value = $serializer->serialize($reference);
$value = $this->getArrayWithDataTypesInGroupedSnakListAtPath($value, 'snaks');
if ($this->addMetaData) {
$value = $this->getReferenceArrayWithMetaData($value);
}
$this->setValue(null, 'reference', $value);
}
/**
* @param string[] $params
* @param Statement[] $statements
*/
public function doTestValidRequest(array $params, array $statements)
{
$statements = new StatementList($statements);
$serializer = $this->serializerFactory->newStatementListSerializer();
$expected = $serializer->serialize($statements);
list($resultArray, ) = $this->doApiRequest($params);
$this->assertInternalType('array', $resultArray, 'top level element is an array');
$this->assertArrayHasKey('claims', $resultArray, 'top level element has a claims key');
// Assert that value mainsnaks have a datatype added
foreach ($resultArray['claims'] as &$claimsByProperty) {
foreach ($claimsByProperty as &$claimArray) {
$this->assertArrayHasKey('datatype', $claimArray['mainsnak']);
unset($claimArray['mainsnak']['datatype']);
}
}
$this->assertEquals($expected, $resultArray['claims']);
}
/**
* @return Serializer
*/
public function newEntitySerializer()
{
$factory = new SerializerFactory(new DataValueSerializer());
return new DispatchingSerializer(array(new SerializedEntitySerializer(), $factory->newEntitySerializer()));
}
public function getEntitySerializer() : Serializer
{
$factory = new SerializerFactory(new DataValueSerializer());
return $factory->newEntitySerializer();
}
private function getSnakSerializer()
{
$factory = new SerializerFactory(new DataValueSerializer());
return $factory->newSnakSerializer();
}
public function testNewSnakListSerializerWithUseObjectsForMaps()
{
$factory = new SerializerFactory(new DataValueSerializer(), SerializerFactory::OPTION_OBJECTS_FOR_MAPS);
$serializer = $factory->newSnakListSerializer();
$this->assertAttributeSame(true, 'useObjectsForMaps', $serializer);
}
/**
* @param Statement|array $statement Native or serialized statement object.
* @param ItemId $itemId
* @param int $expectedCount
* @param string $requestLabel A label to identify requests that are made in errors.
* @param int|null $index
* @param int|null $baserevid
* @param string|null $error
*/
private function makeRequest($statement, ItemId $itemId, $expectedCount, $requestLabel, $index = null, $baserevid = null, $error = null)
{
$serializerFactory = new SerializerFactory(new DataValueSerializer());
$statementSerializer = $serializerFactory->newStatementSerializer();
$statementDeserializer = WikibaseRepo::getDefaultInstance()->getStatementDeserializer();
if ($statement instanceof Statement) {
$serialized = $statementSerializer->serialize($statement);
} else {
$serialized = $statement;
$statement = $statementDeserializer->deserialize($serialized);
}
$params = array('action' => 'wbsetclaim', 'claim' => FormatJson::encode($serialized));
if (!is_null($index)) {
$params['index'] = $index;
}
if (!is_null($baserevid)) {
$params['baserevid'] = $baserevid;
}
$resultArray = $this->assertApiRequest($params, $error);
if ($resultArray) {
$this->assertValidResponse($resultArray);
$this->assertStatementWasSet($statement, $itemId, $expectedCount, $requestLabel);
}
}
