Wikibase\DataAccess\Tests\FakePrefetchingTermLookup

Complexity

Total Complexity

27

Size/Duplication

Total Lines	115
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	prefetchTerms()	0	9	3
A	bufferFakeTermsForEntities()	0	13	5
A	bufferNonAliasTerm()	0	3	1
A	bufferAliasTerms()	0	5	1
A	generateFakeTerm()	0	5	2
A	getPrefetchedTerms()	0	13	4
A	getPrefetchedTerm()	0	4	1
A	getLabel()	0	3	1
A	getLabels()	0	8	2
A	getDescription()	0	3	1
A	getDescriptions()	0	8	2
A	getPrefetchedAliases()	0	12	4

<?php

namespace Wikibase\DataAccess\Tests;

use Wikibase\DataAccess\PrefetchingTermLookup;
use Wikibase\DataModel\Entity\EntityId;
use Wikibase\DataModel\Term\TermTypes;

/**
 * A PrefetchingTermLookup providing dummy TermLookup functionality, i.e. always returning a fake label/description,
 * and optional aliases, and also a Spy on TermBuffer
 * i.e. provides access to "prefetched" terms stored in the buffer after prefetchTerms method is called.
 *
 * @license GPL-2.0-or-later
 */
class FakePrefetchingTermLookup implements PrefetchingTermLookup {

	private $buffer;

	/**
	 * @param array $entityIds
	 * @param array|null $termTypes if null, defaults to labels and descriptions only
	 * @param array|null $languageCodes if null, defaults to de and en
	 */
	public function prefetchTerms( array $entityIds, array $termTypes, array $languageCodes ) {
		if ( $termTypes === null ) {
			$termTypes = [ TermTypes::TYPE_LABEL, TermTypes::TYPE_DESCRIPTION ];
		}
		if ( $languageCodes === null ) {
			$languageCodes = [ 'de', 'en' ];
		}
		$this->bufferFakeTermsForEntities( $entityIds, $termTypes, $languageCodes );
	}

	private function bufferFakeTermsForEntities( array $entityIds, array $termTypes, array $languageCodes ) {
		foreach ( $entityIds as $id ) {
			foreach ( $termTypes as $type ) {
				foreach ( $languageCodes as $lang ) {
					if ( $type !== TermTypes::TYPE_ALIAS ) {
						$this->bufferNonAliasTerm( $id, $type, $lang );
					} else {
						$this->bufferAliasTerms( $id, $type, $lang );
					}
				}
			}
		}
	}

	private function bufferNonAliasTerm( EntityId $id, $type, $lang ) {
		$this->buffer[$id->getSerialization()][$type][$lang] = $this->generateFakeTerm( $id, $type, $lang );
	}

	private function bufferAliasTerms( EntityId $id, $type, $lang ) {
		$this->buffer[$id->getSerialization()][$type][$lang] = [];
		$this->buffer[$id->getSerialization()][$type][$lang][] = $this->generateFakeTerm( $id, $type, $lang, 1 );
		$this->buffer[$id->getSerialization()][$type][$lang][] = $this->generateFakeTerm( $id, $type, $lang, 2 );
	}

	/**
	 * @param EntityId $id
	 * @param string $type
	 * @param string $lang
	 * @param int $count Used for aliases
	 * @return string
	 */
	private function generateFakeTerm( EntityId $id, $type, $lang, $count = 0 ) {
		$suffix = $count ? ' ' . $count : '';

		return $id->getSerialization() . ' ' . $lang . ' ' . $type . $suffix;
	}

	public function getPrefetchedTerms() {
		$terms = [];

		foreach ( $this->buffer as $entityTerms ) {
			foreach ( $entityTerms as $termsByLang ) {
				foreach ( $termsByLang as $term ) {
					$terms[] = $term;
				}
			}
		}

		return $terms;
	}

	public function getPrefetchedTerm( EntityId $entityId, $termType, $languageCode ) {
		$id = $entityId->getSerialization();
		return $this->buffer[$id][$termType][$languageCode] ?? null;
	}

	public function getLabel( EntityId $entityId, $languageCode ) {
		return $this->generateFakeTerm( $entityId, TermTypes::TYPE_LABEL, $languageCode );
	}

	public function getLabels( EntityId $entityId, array $languageCodes ) {
		$labels = [];

		foreach ( $languageCodes as $lang ) {
			$labels[$lang] = $this->generateFakeTerm( $entityId, TermTypes::TYPE_LABEL, $lang );
		}
		return $labels;
	}

	public function getDescription( EntityId $entityId, $languageCode ) {
		return $this->generateFakeTerm( $entityId, TermTypes::TYPE_DESCRIPTION, $languageCode );
	}

	public function getDescriptions( EntityId $entityId, array $languageCodes ) {
		$descriptions = [];

		foreach ( $languageCodes as $lang ) {
			$descriptions[$lang] = $this->generateFakeTerm( $entityId, TermTypes::TYPE_DESCRIPTION, $lang );
		}
		return $descriptions;
	}

	public function getPrefetchedAliases( EntityId $entityId, $languageCode ) {
		$id = $entityId->getSerialization();
		if ( array_key_exists( $id, $this->buffer ) ) {
			if ( array_key_exists( TermTypes::TYPE_ALIAS, $this->buffer[$id] ) ) {
				if ( array_key_exists( $languageCode, $this->buffer[$id][TermTypes::TYPE_ALIAS] ) ) {
					return $this->buffer[$id][TermTypes::TYPE_ALIAS][$languageCode];
				}
			}
		}

		return [];

The return type of return array(); (array) is incompatible with the return type declared by the interface Wikibase\DataAccess\AliasTermBuffer::getPrefetchedAliases of type string[]|false|null.

	}

}