13964287980

Committed 20 Mar 2025 07:43AM UTC coverage: 28.713% (-3.0%) from 31.683%

Build # 13964287980

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #171 from Yoast/JRF/tests-fix-broken-covers-tags

Tests: fix broken `@covers` tags

Run Details

87 of 303 relevant lines covered (28.71%)

2.63 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

55.56

/src/RequirementsChecker.php

<?php

namespace Yoast\WHIPv2;

use Yoast\WHIPv2\Exceptions\InvalidType;
use Yoast\WHIPv2\Interfaces\Message;
use Yoast\WHIPv2\Interfaces\Requirement;
use Yoast\WHIPv2\Messages\InvalidVersionRequirementMessage;
use Yoast\WHIPv2\Messages\UpgradePhpMessage;

/**
 * Main controller class to require a certain version of software.
 */
class RequirementsChecker {

        /**
         * Requirements the environment should comply with.
         *
         * @var array<Requirement>
         */
        private $requirements;

        /**
         * The configuration to check.
         *
         * @var Configuration
         */
        private $configuration;

        /**
         * Message Manager.
         *
         * @var MessagesManager
         */
        private $messageManager;

        /**
         * The text domain to use for translations.
         *
         * @var string
         */
        private $textdomain;

        /**
         * RequirementsChecker constructor.
         *
         * @param array<string, string> $configuration The configuration to check.
         * @param string                $textdomain    The text domain to use for translations.
         *
         * @throws InvalidType When the $configuration parameter is not of the expected type.
         */
        public function __construct( $configuration = array(), $textdomain = 'default' ) {
                $this->requirements   = array();
                $this->configuration  = new Configuration( $configuration );
                $this->messageManager = new MessagesManager();
                $this->textdomain     = $textdomain;
        }

        /**
         * Adds a requirement to the list of requirements if it doesn't already exist.
         *
         * @param Requirement $requirement The requirement to add.
         *
         * @return void
         */
        public function addRequirement( Requirement $requirement ) {
                // Only allow unique entries to ensure we're not checking specific combinations multiple times.
                if ( $this->requirementExistsForComponent( $requirement->component() ) ) {
                        return;
                }

                $this->requirements[] = $requirement;
        }

        /**
         * Determines whether or not there are requirements available.
         *
         * @return bool Whether or not there are requirements.
         */
        public function hasRequirements() {
                return $this->totalRequirements() > 0;
        }

        /**
         * Gets the total amount of requirements.
         *
         * @return int The total amount of requirements.
         */
        public function totalRequirements() {
                return \count( $this->requirements );
        }

        /**
         * Determines whether or not a requirement exists for a particular component.
         *
         * @param string $component The component to check for.
         *
         * @return bool Whether or not the component has a requirement defined.
         */
        public function requirementExistsForComponent( $component ) {
                foreach ( $this->requirements as $requirement ) {
                        if ( $requirement->component() === $component ) {
                                return true;
                        }
                }

                return false;
        }

        /**
         * Determines whether a requirement has been fulfilled.
         *
         * @param Requirement $requirement The requirement to check.
         *
         * @return bool Whether or not the requirement is fulfilled.
         */
        private function requirementIsFulfilled( Requirement $requirement ) {
                $availableVersion = $this->configuration->configuredVersion( $requirement );
                $requiredVersion  = $requirement->version();

                if ( \in_array( $requirement->operator(), array( '=', '==', '===' ), true ) ) {
                        return \version_compare( $availableVersion, $requiredVersion, '>=' );
                }

                return \version_compare( $availableVersion, $requiredVersion, $requirement->operator() );
        }

        /**
         * Checks if all requirements are fulfilled and adds a message to the message manager if necessary.
         *
         * @return void
         */
        public function check() {
                foreach ( $this->requirements as $requirement ) {
                        // Match against config.
                        $requirementFulfilled = $this->requirementIsFulfilled( $requirement );

                        if ( $requirementFulfilled ) {
                                continue;
                        }

                        $this->addMissingRequirementMessage( $requirement );
                }
        }

        /**
         * Adds a message to the message manager for requirements that cannot be fulfilled.
         *
         * @param Requirement $requirement The requirement that cannot be fulfilled.
         *
         * @return void
         */
        private function addMissingRequirementMessage( Requirement $requirement ) {
                switch ( $requirement->component() ) {
                        case 'php':
                                $this->messageManager->addMessage( new UpgradePhpMessage( $this->textdomain ) );
                                break;
                        default:
                                $this->messageManager->addMessage( new InvalidVersionRequirementMessage( $requirement, $this->configuration->configuredVersion( $requirement ) ) );
                                break;
                }
        }

        /**
         * Determines whether or not there are messages available.
         *
         * @return bool Whether or not there are messages to display.
         */
        public function hasMessages() {
                return $this->messageManager->hasMessages();
        }

        /**
         * Gets the most recent message from the message manager.
         *
         * @return Message The latest message.
         */
        public function getMostRecentMessage() {
                return $this->messageManager->getLatestMessage();
        }
}

1	<?php
2
3	namespace Yoast\WHIPv2;
4
5	use Yoast\WHIPv2\Exceptions\InvalidType;
6	use Yoast\WHIPv2\Interfaces\Message;
7	use Yoast\WHIPv2\Interfaces\Requirement;
8	use Yoast\WHIPv2\Messages\InvalidVersionRequirementMessage;
9	use Yoast\WHIPv2\Messages\UpgradePhpMessage;
10
11	/**
12	* Main controller class to require a certain version of software.
13	*/
14	class RequirementsChecker {
15
16	/**
17	* Requirements the environment should comply with.
18	*
19	* @var array<Requirement>
20	*/
21	private $requirements;
22
23	/**
24	* The configuration to check.
25	*
26	* @var Configuration
27	*/
28	private $configuration;
29
30	/**
31	* Message Manager.
32	*
33	* @var MessagesManager
34	*/
35	private $messageManager;
36
37	/**
38	* The text domain to use for translations.
39	*
40	* @var string
41	*/
42	private $textdomain;
43
44	/**
45	* RequirementsChecker constructor.
46	*
47	* @param array<string, string> $configuration The configuration to check.
48	* @param string $textdomain The text domain to use for translations.
49	*
50	* @throws InvalidType When the $configuration parameter is not of the expected type.
51	*/
52	public function __construct( $configuration = array(), $textdomain = 'default' ) {	×
53	$this->requirements = array();	×
54	$this->configuration = new Configuration( $configuration );	×
55	$this->messageManager = new MessagesManager();	×
56	$this->textdomain = $textdomain;	×
57	}
58
59	/**
60	* Adds a requirement to the list of requirements if it doesn't already exist.
61	*
62	* @param Requirement $requirement The requirement to add.
63	*
64	* @return void
65	*/
66	public function addRequirement( Requirement $requirement ) {	24✔
67	// Only allow unique entries to ensure we're not checking specific combinations multiple times.
68	if ( $this->requirementExistsForComponent( $requirement->component() ) ) {	24✔
69	return;	4✔
70	}
71
72	$this->requirements[] = $requirement;	24✔
73	}	16✔
74
75	/**
76	* Determines whether or not there are requirements available.
77	*
78	* @return bool Whether or not there are requirements.
79	*/
80	public function hasRequirements() {	×
81	return $this->totalRequirements() > 0;	×
82	}
83
84	/**
85	* Gets the total amount of requirements.
86	*
87	* @return int The total amount of requirements.
88	*/
89	public function totalRequirements() {	6✔
90	return \count( $this->requirements );	6✔
91	}
92
93	/**
94	* Determines whether or not a requirement exists for a particular component.
95	*
96	* @param string $component The component to check for.
97	*
98	* @return bool Whether or not the component has a requirement defined.
99	*/
100	public function requirementExistsForComponent( $component ) {	3✔
101	foreach ( $this->requirements as $requirement ) {	3✔
102	if ( $requirement->component() === $component ) {	3✔
103	return true;	3✔
104	}
105	}	1✔
106
107	return false;	3✔
108	}
109
110	/**
111	* Determines whether a requirement has been fulfilled.
112	*
113	* @param Requirement $requirement The requirement to check.
114	*
115	* @return bool Whether or not the requirement is fulfilled.
116	*/
117	private function requirementIsFulfilled( Requirement $requirement ) {	×
118	$availableVersion = $this->configuration->configuredVersion( $requirement );	×
119	$requiredVersion = $requirement->version();	×
120
121	if ( \in_array( $requirement->operator(), array( '=', '==', '===' ), true ) ) {	×
122	return \version_compare( $availableVersion, $requiredVersion, '>=' );	×
123	}
124
125	return \version_compare( $availableVersion, $requiredVersion, $requirement->operator() );	×
126	}
127
128	/**
129	* Checks if all requirements are fulfilled and adds a message to the message manager if necessary.
130	*
131	* @return void
132	*/
133	public function check() {	15✔
134	foreach ( $this->requirements as $requirement ) {	15✔
135	// Match against config.
136	$requirementFulfilled = $this->requirementIsFulfilled( $requirement );	15✔
137
138	if ( $requirementFulfilled ) {	15✔
139	continue;	6✔
140	}
141
142	$this->addMissingRequirementMessage( $requirement );	9✔
143	}	5✔
144	}	10✔
145
146	/**
147	* Adds a message to the message manager for requirements that cannot be fulfilled.
148	*
149	* @param Requirement $requirement The requirement that cannot be fulfilled.
150	*
151	* @return void
152	*/
153	private function addMissingRequirementMessage( Requirement $requirement ) {	×
154	switch ( $requirement->component() ) {	×
155	case 'php':	×
156	$this->messageManager->addMessage( new UpgradePhpMessage( $this->textdomain ) );	×
157	break;	×
158	default:
159	$this->messageManager->addMessage( new InvalidVersionRequirementMessage( $requirement, $this->configuration->configuredVersion( $requirement ) ) );	×
160	break;	×
161	}
162	}
163
164	/**
165	* Determines whether or not there are messages available.
166	*
167	* @return bool Whether or not there are messages to display.
168	*/
169	public function hasMessages() {	12✔
170	return $this->messageManager->hasMessages();	12✔
171	}
172
173	/**
174	* Gets the most recent message from the message manager.
175	*
176	* @return Message The latest message.
177	*/
178	public function getMostRecentMessage() {	9✔
179	return $this->messageManager->getLatestMessage();	9✔
180	}
181	}

Yoast / whip / 13964287980

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous