Update AssertSameWithCountRule for assertSameSize

Expanded the AssertSameWithCountRule in PHPUnit rules to handle additional scenarios. Now the rule checks if both sides of the assertSame are counts, and suggests assertSameSize instead when necessary. The modification enhances the rule's applicability and accuracy.
phpstan · Apr 4, 2024 · f74e9be · f74e9be
1 parent f93aec7
commit f74e9be
Show file tree

Hide file tree

Showing 3 changed files with 113 additions and 21 deletions.
diff --git a/src/Rules/PHPUnit/AssertSameWithCountRule.php b/src/Rules/PHPUnit/AssertSameWithCountRule.php
@@ -37,36 +37,81 @@ public function processNode(Node $node, Scope $scope): array
 
 		$right = $node->getArgs()[1]->value;
 
-		if (
-			$right instanceof Node\Expr\FuncCall
-			&& $right->name instanceof Node\Name
-			&& $right->name->toLowerString() === 'count'
-		) {
-			return [
-				RuleErrorBuilder::message('You should use assertCount($expectedCount, $variable) instead of assertSame($expectedCount, count($variable)).')
-					->identifier('phpunit.assertCount')
-					->build(),
-			];
+		$rightIsCountFuncCall = $this->isCountFuncCall($right);
+		$rightIsCountMethodCall = $this->isCountMethodCall($right) && $this->argIsCountable($scope, $right);
+		if (!($rightIsCountFuncCall || $rightIsCountMethodCall)) {
+			return [];
 		}
 
-		if (
-			$right instanceof Node\Expr\MethodCall
-			&& $right->name instanceof Node\Identifier
-			&& $right->name->toLowerString() === 'count'
-			&& count($right->getArgs()) === 0
-		) {
-			$type = $scope->getType($right->var);
+		$left = $node->getArgs()[0]->value;
+		$leftIsCountFuncCall = $this->isCountFuncCall($left);
+		$leftIsCountMethodCall = $this->isCountMethodCall($left) && $this->argIsCountable($scope, $left);
+
+		if ($rightIsCountFuncCall) {
+			if ($leftIsCountFuncCall) {
+				return [
+					RuleErrorBuilder::message('You should use assertSameSize($expected, $variable) instead of assertSame(count($expected), count($variable)).')
+						->identifier('phpunit.assertSameSize')
+						->build(),
+				];
+			} elseif ($leftIsCountMethodCall) {
+				return [
+					RuleErrorBuilder::message('You should use assertSameSize($expected, $variable) instead of assertSame($expected->count(), count($variable)).')
+						->identifier('phpunit.assertSameSize')
+						->build(),
+				];
 
-			if ((new ObjectType(Countable::class))->isSuperTypeOf($type)->yes()) {
+			} else {
+				return [
+					RuleErrorBuilder::message('You should use assertCount($expectedCount, $variable) instead of assertSame($expectedCount, count($variable)).')
+						->identifier('phpunit.assertCount')
+						->build(),
+				];
+			}
+		} else {
+			if ($leftIsCountFuncCall) {
+				return [
+					RuleErrorBuilder::message('You should use assertSameSize($expected, $variable) instead of assertSame(count($expected), $variable->count()).')
+						->identifier('phpunit.assertSameSize')
+						->build(),
+				];
+			} elseif ($leftIsCountMethodCall) {
+				return [
+					RuleErrorBuilder::message('You should use assertSameSize($expected, $variable) instead of assertSame($expected->count(), $variable->count()).')
+						->identifier('phpunit.assertSameSize')
+						->build(),
+				];
+			} else {
 				return [
 					RuleErrorBuilder::message('You should use assertCount($expectedCount, $variable) instead of assertSame($expectedCount, $variable->count()).')
 						->identifier('phpunit.assertCount')
 						->build(),
 				];
 			}
 		}
+	}
+
+	private function isCountFuncCall(Node\Expr $expr): bool
+	{
+		return $expr instanceof Node\Expr\FuncCall
+			&& $expr->name instanceof Node\Name
+			&& $expr->name->toLowerString() === 'count';
+	}
+
+	private function isCountMethodCall(Node\Expr $expr): bool
+	{
+		return $expr instanceof Node\Expr\MethodCall
+			&& $expr->name instanceof Node\Identifier
+			&& $expr->name->toLowerString() === 'count'
+			&& count($expr->getArgs()) === 0;
+	}
+
+	private function argIsCountable(Scope $scope, Node\Expr $expr): bool
+	{
+		$type = $scope->getType($expr->var);
+		$countableType = new ObjectType(Countable::class);
 
-		return [];
+		return $countableType->isSuperTypeOf($type)->yes();
 	}
 
 }
diff --git a/tests/Rules/PHPUnit/AssertSameWithCountRuleTest.php b/tests/Rules/PHPUnit/AssertSameWithCountRuleTest.php
@@ -23,13 +23,29 @@ public function testRule(): void
 				'You should use assertCount($expectedCount, $variable) instead of assertSame($expectedCount, count($variable)).',
 				10,
 			],
+			[
+				'You should use assertSameSize($expected, $variable) instead of assertSame(count($expected), count($variable)).',
+				15,
+			],
+			[
+				'You should use assertSameSize($expected, $variable) instead of assertSame($expected->count(), count($variable)).',
+				23,
+			],
 			[
 				'You should use assertCount($expectedCount, $variable) instead of assertSame($expectedCount, count($variable)).',
-				22,
+				35,
 			],
 			[
 				'You should use assertCount($expectedCount, $variable) instead of assertSame($expectedCount, $variable->count()).',
-				30,
+				43,
+			],
+			[
+				'You should use assertSameSize($expected, $variable) instead of assertSame(count($expected), $variable->count()).',
+				51,
+			],
+			[
+				'You should use assertSameSize($expected, $variable) instead of assertSame($expected->count(), $variable->count()).',
+				61,
 			],
 		]);
 	}

diff --git a/tests/Rules/PHPUnit/data/assert-same-count.php b/tests/Rules/PHPUnit/data/assert-same-count.php
@@ -10,6 +10,19 @@ public function testAssertSameWithCount()
 		$this->assertSame(5, count([1, 2, 3]));
 	}
 
+	public function testAssertSameWithCountExpectedWithCount()
+	{
+		$this->assertSame(count([10, 20]), count([1, 2, 3]));
+	}
+
+	public function testAssertSameWithCountExpectedMethodWithCountMethod()
+	{
+		$foo = new \stdClass();
+		$foo->bar = new Bar ();
+
+		$this->assertSame($foo->bar->count(), count([1, 2, 3]));
+	}
+
 	public function testAssertSameWithCountMethodIsOK()
 	{
 		$foo = new \stdClass();
@@ -30,6 +43,24 @@ public function testAssertSameWithCountMethodForCountableVariableIsNotOK()
 		$this->assertSame(5, $foo->bar->count());
 	}
 
+	public function testAssertSameWithCountExpectedWithCountMethodForCountableVariableIsNot()
+	{
+		$foo = new \stdClass();
+		$foo->bar = new Bar ();
+
+		$this->assertSame(count([10, 20]), $foo->bar->count());
+	}
+
+	public function testAssertSameWithCountExpectedMethodWithCountMethodForCountableVariableIsNot()
+	{
+		$foo = new \stdClass();
+		$foo->bar = new Bar ();
+		$foo2 = new \stdClass();
+		$foo2->bar = new Bar ();
+
+		$this->assertSame($foo2->bar->count(), $foo->bar->count());
+	}
+
 }
 
 class Bar implements \Countable {