QuantityHtmlFormatterTest::getQuantityHtmlFormatter() - Code Metrics - wmde/Number - Measure and Improve Code Quality continuously with Scrutinizer

getQuantityHtmlFormatter() A
last analyzed 2021-03-31 13:58 UTC

↳ Parent: QuantityHtmlFormatterTest

Complexity

Conditions	2
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
dl	0
loc	19
rs	9.6333
c	0
b	0
f	0
cc	2
nc	1
nop	3

<?php

namespace ValueFormatters\Test;

use DataValues\DecimalValue;
use DataValues\QuantityValue;
use DataValues\UnboundedQuantityValue;
use PHPUnit\Framework\TestCase;
use ValueFormatters\DecimalFormatter;
use ValueFormatters\FormatterOptions;
use ValueFormatters\QuantityHtmlFormatter;
use ValueFormatters\ValueFormatter;

/**
 * @covers ValueFormatters\QuantityHtmlFormatter
 *
 * @license GPL-2.0-or-later
 * @author Thiemo Kreuz
 */
class QuantityHtmlFormatterTest extends TestCase {

	/**
	 * @see ValueFormatterTestBase::getInstance
	 *
	 * @param FormatterOptions|null $options
	 *
	 * @return QuantityHtmlFormatter
	 */
	protected function getInstance( FormatterOptions $options = null ) {
		return $this->getQuantityHtmlFormatter( $options );
	}

	/**
	 * @param FormatterOptions|null $options
	 * @param DecimalFormatter|null $decimalFormatter
	 * @param string|null $quantityWithUnitFormat
	 *
	 * @return QuantityHtmlFormatter
	 */
	private function getQuantityHtmlFormatter(
		FormatterOptions $options = null,
		DecimalFormatter $decimalFormatter = null,
		$quantityWithUnitFormat = null
	) {
		$vocabularyUriFormatter = $this->createMock( ValueFormatter::class );
		$vocabularyUriFormatter->expects( $this->any() )
			->method( 'format' )
			->will( $this->returnCallback( function ( $unit ) {
				return $unit === '1' ? null : $unit;
			} ) );

		return new QuantityHtmlFormatter(
			$options,
			$decimalFormatter,
			$vocabularyUriFormatter,
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
			$quantityWithUnitFormat
		);
	}

	/**
	 * @param string $className
	 * @param int $uncertaintyMargin
	 *
	 * @return QuantityValue
	 */
	private function newQuantityValue( $className, $uncertaintyMargin = 0 ) {
		$quantity = $this->getMockBuilder( $className )
			->disableOriginalConstructor()
			->getMock();

		$quantity->expects( $this->any() )
			->method( 'getAmount' )
			->will( $this->returnValue( new DecimalValue( 2 ) ) );
		if ( $className === QuantityValue::class ) {
			$quantity->expects( $this->any() )
				->method( 'getUncertaintyMargin' )
				->will( $this->returnValue( new DecimalValue( $uncertaintyMargin ) ) );
		}

		return $quantity;
	}

	/**
	 * @see ValueFormatterTestBase::validProvider
	 */
	public function validProvider() {
		return [
			'Unbounded, Unit 1' => [
				UnboundedQuantityValue::newFromNumber( '+2', '1' ),
				'2'
			],
			'Unbounded, String unit' => [
				UnboundedQuantityValue::newFromNumber( '+2', 'Ultrameter' ),
				'2 <span class="wb-unit">Ultrameter</span>'
			],
			'Unit 1' => [
				QuantityValue::newFromNumber( '+2', '1', '+3', '+1' ),
				'2±1'
			],
			'String unit' => [
				QuantityValue::newFromNumber( '+2', 'Ultrameter', '+3', '+1' ),
				'2±1 <span class="wb-unit">Ultrameter</span>'
			],
			'HTML injection' => [
				QuantityValue::newFromNumber( '+2', '<b>injection</b>', '+2', '+2' ),
				'2±0 <span class="wb-unit">&lt;b&gt;injection&lt;/b&gt;</span>'
			],
		];
	}

	public function testFormatWithFormatString() {
		$formatter = $this->getQuantityHtmlFormatter( null, null, '$2&thinsp;$1' );
		$value = UnboundedQuantityValue::newFromNumber( '+5', 'USD' );
		$formatted = $formatter->format( $value );
		$this->assertSame( '<span class="wb-unit">USD</span>&thinsp;5', $formatted );
	}

	/**
	 * @dataProvider applyUnitOptionProvider
	 */
	public function testGivenHtmlCharacters_formatEscapesHtmlCharacters(
		?FormatterOptions $options,
		UnboundedQuantityValue $value,
		$expected
	) {
		$decimalFormatter = $this->createMock( DecimalFormatter::class );
		$decimalFormatter->expects( $this->any() )
			->method( 'format' )
			->will( $this->returnValue( '<b>+2</b>' ) );

		$formatter = $this->getQuantityHtmlFormatter( $options, $decimalFormatter );
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
		$formatted = $formatter->format( $value );
		$this->assertSame( $expected, $formatted );
	}

	public function applyUnitOptionProvider() {
		$noUnit = new FormatterOptions();
		$noUnit->setOption( QuantityHtmlFormatter::OPT_APPLY_UNIT, false );

		return [
			'Disabled without unit' => [
				$noUnit,
				UnboundedQuantityValue::newFromNumber( 2, '1' ),
				'&lt;b&gt;+2&lt;/b&gt;'
			],
			'Disabled with unit' => [
				$noUnit,
				UnboundedQuantityValue::newFromNumber( 2, '<b>m</b>' ),
				'&lt;b&gt;+2&lt;/b&gt;'
			],
			'Default without unit' => [
				null,
				UnboundedQuantityValue::newFromNumber( 2, '1' ),
				'&lt;b&gt;+2&lt;/b&gt;'
			],
			'Default with unit' => [
				null,
				UnboundedQuantityValue::newFromNumber( 2, '<b>m</b>' ),
				'&lt;b&gt;+2&lt;/b&gt; <span class="wb-unit">&lt;b&gt;m&lt;/b&gt;</span>'
			],
			'HTML escaping bounded' => [
				null,
				$this->newQuantityValue( QuantityValue::class ),
				'&lt;b&gt;+2&lt;/b&gt;±&lt;b&gt;+2&lt;/b&gt;'
			],
			'HTML escaping bounded with uncertainty' => [
				null,
				$this->newQuantityValue( QuantityValue::class, 1 ),
				'&lt;b&gt;+2&lt;/b&gt;±&lt;b&gt;+2&lt;/b&gt;'
			],
			'HTML escaping unbounded' => [
				null,
				$this->newQuantityValue( UnboundedQuantityValue::class ),
				'&lt;b&gt;+2&lt;/b&gt;'
			],
		];
	}

}


1			<?php
2
3			namespace ValueFormatters\Test;
4
5			use DataValues\DecimalValue;
6			use DataValues\QuantityValue;
7			use DataValues\UnboundedQuantityValue;
8			use PHPUnit\Framework\TestCase;
9			use ValueFormatters\DecimalFormatter;
10			use ValueFormatters\FormatterOptions;
11			use ValueFormatters\QuantityHtmlFormatter;
12			use ValueFormatters\ValueFormatter;
13
14			/**
15			* @covers ValueFormatters\QuantityHtmlFormatter
16			*
17			* @license GPL-2.0-or-later
18			* @author Thiemo Kreuz
19			*/
20			class QuantityHtmlFormatterTest extends TestCase {
21
22			/**
23			* @see ValueFormatterTestBase::getInstance
24			*
25			* @param FormatterOptions\|null $options
26			*
27			* @return QuantityHtmlFormatter
28			*/
29			protected function getInstance( FormatterOptions $options = null ) {
30			return $this->getQuantityHtmlFormatter( $options );
31			}
32
33			/**
34			* @param FormatterOptions\|null $options
35			* @param DecimalFormatter\|null $decimalFormatter
36			* @param string\|null $quantityWithUnitFormat
37			*
38			* @return QuantityHtmlFormatter
39			*/
40			private function getQuantityHtmlFormatter(
41			FormatterOptions $options = null,
42			DecimalFormatter $decimalFormatter = null,
43			$quantityWithUnitFormat = null
44			) {
45			$vocabularyUriFormatter = $this->createMock( ValueFormatter::class );
46			$vocabularyUriFormatter->expects( $this->any() )
47			->method( 'format' )
48			->will( $this->returnCallback( function ( $unit ) {
49			return $unit === '1' ? null : $unit;
50			} ) );
51
52			return new QuantityHtmlFormatter(
53			$options,
54			$decimalFormatter,
55			$vocabularyUriFormatter,
			0 ignored issues – show Documentation introduced 2020-10-19 15:41 UTC by Report Bug Copy Issue Report `$vocabularyUriFormatter` is of type `object<PHPUnit\Framework\MockObject\MockObject>`, but the function expects a `object<ValueFormatters\ValueFormatter>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
56			$quantityWithUnitFormat
57			);
58			}
59
60			/**
61			* @param string $className
62			* @param int $uncertaintyMargin
63			*
64			* @return QuantityValue
65			*/
66			private function newQuantityValue( $className, $uncertaintyMargin = 0 ) {
67			$quantity = $this->getMockBuilder( $className )
68			->disableOriginalConstructor()
69			->getMock();
70
71			$quantity->expects( $this->any() )
72			->method( 'getAmount' )
73			->will( $this->returnValue( new DecimalValue( 2 ) ) );
74			if ( $className === QuantityValue::class ) {
75			$quantity->expects( $this->any() )
76			->method( 'getUncertaintyMargin' )
77			->will( $this->returnValue( new DecimalValue( $uncertaintyMargin ) ) );
78			}
79
80			return $quantity;
81			}
82
83			/**
84			* @see ValueFormatterTestBase::validProvider
85			*/
86			public function validProvider() {
87			return [
88			'Unbounded, Unit 1' => [
89			UnboundedQuantityValue::newFromNumber( '+2', '1' ),
90			'2'
91			],
92			'Unbounded, String unit' => [
93			UnboundedQuantityValue::newFromNumber( '+2', 'Ultrameter' ),
94			'2 <span class="wb-unit">Ultrameter</span>'
95			],
96			'Unit 1' => [
97			QuantityValue::newFromNumber( '+2', '1', '+3', '+1' ),
98			'2±1'
99			],
100			'String unit' => [
101			QuantityValue::newFromNumber( '+2', 'Ultrameter', '+3', '+1' ),
102			'2±1 <span class="wb-unit">Ultrameter</span>'
103			],
104			'HTML injection' => [
105			QuantityValue::newFromNumber( '+2', '<b>injection</b>', '+2', '+2' ),
106			'2±0 <span class="wb-unit"><b>injection</b></span>'
107			],
108			];
109			}
110
111			public function testFormatWithFormatString() {
112			$formatter = $this->getQuantityHtmlFormatter( null, null, '$2 $1' );
113			$value = UnboundedQuantityValue::newFromNumber( '+5', 'USD' );
114			$formatted = $formatter->format( $value );
115			$this->assertSame( '<span class="wb-unit">USD</span> 5', $formatted );
116			}
117
118			/**
119			* @dataProvider applyUnitOptionProvider
120			*/
121			public function testGivenHtmlCharacters_formatEscapesHtmlCharacters(
122			?FormatterOptions $options,
123			UnboundedQuantityValue $value,
124			$expected
125			) {
126			$decimalFormatter = $this->createMock( DecimalFormatter::class );
127			$decimalFormatter->expects( $this->any() )
128			->method( 'format' )
129			->will( $this->returnValue( '<b>+2</b>' ) );
130
131			$formatter = $this->getQuantityHtmlFormatter( $options, $decimalFormatter );
			0 ignored issues – show Documentation introduced 2020-10-19 15:41 UTC by Report Bug Copy Issue Report `$decimalFormatter` is of type `object<PHPUnit\Framework\MockObject\MockObject>`, but the function expects a `null\|object<ValueFormatters\DecimalFormatter>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
132			$formatted = $formatter->format( $value );
133			$this->assertSame( $expected, $formatted );
134			}
135
136			public function applyUnitOptionProvider() {
137			$noUnit = new FormatterOptions();
138			$noUnit->setOption( QuantityHtmlFormatter::OPT_APPLY_UNIT, false );
139
140			return [
141			'Disabled without unit' => [
142			$noUnit,
143			UnboundedQuantityValue::newFromNumber( 2, '1' ),
144			'<b>+2</b>'
145			],
146			'Disabled with unit' => [
147			$noUnit,
148			UnboundedQuantityValue::newFromNumber( 2, '<b>m</b>' ),
149			'<b>+2</b>'
150			],
151			'Default without unit' => [
152			null,
153			UnboundedQuantityValue::newFromNumber( 2, '1' ),
154			'<b>+2</b>'
155			],
156			'Default with unit' => [
157			null,
158			UnboundedQuantityValue::newFromNumber( 2, '<b>m</b>' ),
159			'<b>+2</b> <span class="wb-unit"><b>m</b></span>'
160			],
161			'HTML escaping bounded' => [
162			null,
163			$this->newQuantityValue( QuantityValue::class ),
164			'<b>+2</b>±<b>+2</b>'
165			],
166			'HTML escaping bounded with uncertainty' => [
167			null,
168			$this->newQuantityValue( QuantityValue::class, 1 ),
169			'<b>+2</b>±<b>+2</b>'
170			],
171			'HTML escaping unbounded' => [
172			null,
173			$this->newQuantityValue( UnboundedQuantityValue::class ),
174			'<b>+2</b>'
175			],
176			];
177			}
178
179			}
180

wmde / Number

getQuantityHtmlFormatter() A last analyzed 2021-03-31 13:58 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

getQuantityHtmlFormatter() A
last analyzed 2021-03-31 13:58 UTC