Merge pull request #66 from AndreasMalecki/add-support-for-mockery

Add support for mockery

Author: Haehnchen

README.md

@@ -24,18 +24,19 @@ Stable version, JetBrains repository:
 
 ## Feature list
 
-* method autocomplete for class, abstract class and trait mock objects;
- * type providers: `getMock`, `getMockForAbstractClass`, etc. will return mock object with methods of mocking class and `PHPUnit_Framework_MockObject_MockObject`;
- * supported PHPUnit methods:
+* Method autocompletion for class, abstract class and trait mock objects;
+ * Type providers: `getMock`, `getMockForAbstractClass`, etc. will return mock object with methods of mocking class and `PHPUnit_Framework_MockObject_MockObject`;
+ * Supported PHPUnit methods:
  * `PHPUnit_Framework_MockObject_MockBuilder::setMethods`
  * `PHPUnit_Framework_TestCase::getMock`
  * `PHPUnit_Framework_TestCase::getMockClass`
  * `PHPUnit_Framework_TestCase::getMockForAbstractClass`
  * `PHPUnit_Framework_TestCase::getMockForTrait`
  * `PHPUnit_Framework_MockObject_Builder_InvocationMocker::method` 
-* code navigation (go to declaration, find usages, etc.) and refactoring (rename methods);
-* highlighting of incorrect method usages;
+* Code navigation (go to declaration, find usages, etc.) and refactoring (rename methods);
+* Highlighting of incorrect method usages;
 * Prophecy support.
+* Mockery support.
 
 ### Mocks
 
@@ -197,4 +198,200 @@ Examples
 
 ![PHPUnit Prophecy](https://jetbrains-plugins.s3.amazonaws.com/9674/screenshot_16953.png)
 
-![PHPUnit Expected exception](https://download.plugins.jetbrains.com/9674/screenshot_17449.png)
+![PHPUnitExpected exception](https://download.plugins.jetbrains.com/9674/screenshot_17449.png)
+
+## Mockery
+
+Has support for
+* Method referencing and autocomplete for method string in `allows`, `expects`, `shouldReceive`, `shouldNotReceive`, 
+`shouldHaveReceived`, `shouldNotHaveReceived`. As well as in Generated partial mocks.
+* Highlighting for incorrect methods used inside an `allows` etc., when method is private, protected, or not found.
+* Type providers to enable new Mockery syntax: `$mock->allows()->foo('arg')->andReturns('mocked_result')`.
+* Configurable inspection for replacing legacy Mockery syntax: replacing`$mock->shouldReceive("foo")->with("arg")->andReturn("result")` 
+with `$mock->allows()->foo("arg")->andReturns("result")`. 
+
+### Referencing
+
+In the following code snippets referencing, autocompletion, and refactoring are supported at the carets.
+Note that these all work with aliases, overloaded mocks, proxies, and partial mocks.
+
+```php
+class Foo extends Mockery\Adapter\Phpunit\MockeryTestCase
+{
+ protected function setUp(): void
+ {
+ $mock = Mockery::mock('MockeryPlugin\DemoProject\Dependency');
+ $mock->allows('fo<caret>o');
+ $mock->expects('f<caret>oo');
+ $mock->shouldReceive('ba<caret>r');
+ $mock->shouldNotReceive('b<caret>ar');
+ }
+}
+```
+
+```php
+class Foo extends Mockery\Adapter\Phpunit\MockeryTestCase
+{
+ protected function setUp(): void
+ {
+ $this->mock = Mockery::mock('MockeryPlugin\DemoProject\Dependency');
+ }
+ 
+ public function test(): void
+ {
+ $this->mock->allows('fo<caret>o')->andReturns('result');
+ }
+}
+```
+
+```php
+class Foo extends Mockery\Adapter\Phpunit\MockeryTestCase
+{
+ protected function setUp(): void
+ {
+ $mock = Mockery::spy('MockeryPlugin\DemoProject\Dependency');
+ // ...
+ $mock->shouldHaveReceived('b<caret>ar');
+ $mock->shouldNotHaveReceived('fo<caret>o');
+ }
+}
+```
+
+```php
+class Foo extends Mockery\Adapter\Phpunit\MockeryTestCase
+{
+ protected function setUp(): void
+ {
+ $mock = Mockery::mock('MockeryPlugin\DemoProject\Dependency');
+ $mock->shouldReceive('foo', 'b<caret>ar')
+ $mock->shouldReceive([
+ 'foo' => 'mocked result',
+ 'ba<caret>r' => 'mocked result'
+ ]);
+ }
+}
+```
+
+### Generated Partial Mocks
+
+Method name referencing/refactoring is supported when creating generated partial mocks.
+```php
+class Foo extends Mockery\Adapter\Phpunit\MockeryTestCase
+{
+ protected function setUp(): void
+ {
+ $mock = Mockery::mock(Dependency::class . "[f<caret>oo]");
+ $mock = Mockery::mock('MockeryPlugin\DemoProject\Dependency[f<caret>oo]');
+ }
+}
+```
+
+### Method Annotations
+
+A warning highlight is given when the method being used is protected, private, or not found.
+
+```php
+class Foo extends Mockery\Adapter\Phpunit\MockeryTestCase
+{
+ protected function setUp(): void
+ {
+ $mock = Mockery::mock(Dependency::class);
+ $mock->expects('protectedMethod');
+ $mock->expects('privateMethod');
+ $mock->expects('unknownMethod');
+ }
+}
+```
+
+### Inspection
+
+An inspection is provided which will highlight legacy mockery syntax and provides a quick fix 
+to update. Legacy Mockery uses `shouldReceive`/`shouldNotReceive`, and it gets replaced by `allows`/`expects`, e.g.
+
+```php
+class Foo extends Mockery\Adapter\Phpunit\MockeryTestCase
+{
+ protected function setUp(): void
+ {
+ $mock = Mockery::mock(Dependency::class);
+ $mock->shouldReceive('foo')->with('arg')->andReturn('result');
+ // replaced by
+ $mock->allows('foo')->with('arg')->andReturns('result');
+ 
+ $mock->shouldReceive('foo')->with('arg')->andReturn('result')->once();
+ // replaced by
+ $mock->expects('foo')->with('arg')->andReturns('result');
+ }
+}
+```
+
+If a `shouldReceive` has multiple method parameters then these will get combined into an array parameter. 
+But the inspection can be configured to prefer writing multiple `allows`/`expects` statements.
+
+```php
+class Foo extends Mockery\Adapter\Phpunit\MockeryTestCase
+{
+ protected function setUp(): void
+ {
+ $mock = Mockery::mock(Dependency::class);
+ $mock->$this->dependency->shouldReceive('foo', 'bar');
+ // replaced by
+ $mock->allows(['foo', 'bar']);
+ 
+ $mock->shouldReceive('foo', 'bar')->andReturns('mocked result');
+ // replaced by
+ $mock->allows(['foo' => 'mocked result', 'bar' => 'mocked result']);
+ }
+}
+```
+
+```php
+class Foo extends Mockery\Adapter\Phpunit\MockeryTestCase
+{
+ protected function setUp(): void
+ {
+ $mock = Mockery::mock(Dependency::class);
+ $mock->$this->dependency->shouldReceive('foo', 'bar');
+ // replaced by
+ $this->dependency->allows('foo');
+ $this->dependency->allows('bar');
+ 
+ $mock->shouldReceive('foo', 'bar')->andReturns('mocked result');
+ // replaced by
+ $this->dependency->allows('foo')->andReturns('mocked result');
+ $this->dependency->allows('bar')->andReturns('mocked result'); }
+}
+```
+
+The inspection can also be configured to prefer the new Mockery syntax in which the mocked methods are called
+like normal rather than as a string.
+
+```php
+class Foo extends Mockery\Adapter\Phpunit\MockeryTestCase
+{
+ protected function setUp(): void
+ {
+ $mock = Mockery::mock(Dependency::class);
+ $mock->shouldReceive('foo')->with('arg')->andReturn('result');
+ // replaced by
+ $mock->allows()->foo('arg')->andReturns('result');
+ 
+ $mock->shouldReceive('foo')->with('arg')->andReturn('result')->once();
+ // replaced by
+ $mock->expects()->foo('arg')->andReturns('result');
+ }
+}
+```
+
+### New Mockery Syntax Type Provider
+
+Type providers are implemented so that when calling `allows()` on a mock it will have the type of the 
+mocked class. Further `allows()->foo()` will be given the type Mockery/Expectation so that methods like `andReturns(..)` 
+work as expected. This extends also to `expects()`, `shouldReceive()`, `shouldNotReceive()` and `shouldHaveReceived()`. 
+Note: this new syntax does not extend tp `shouldNotHaveReceived`.
+
+In the following example the first caret has type Dependency, and the second type Expectation.
+```php
+$mock = Mockery::mock(Dependency::class);
+$mock->allows<caret>()->foo<caret>('arg')->andReturns('result');
+```

src/main/java/de/espend/idea/php/phpunit/annotator/MockeryAnnotator.java

@@ -0,0 +1,123 @@
+package de.espend.idea.php.phpunit.annotator;
+
+import com.intellij.lang.annotation.AnnotationHolder;
+import com.intellij.lang.annotation.Annotator;
+import com.intellij.lang.annotation.HighlightSeverity;
+import com.intellij.openapi.util.TextRange;
+import com.intellij.patterns.PsiElementPattern;
+import com.intellij.psi.PsiElement;
+import com.jetbrains.php.PhpIndex;
+import com.jetbrains.php.lang.psi.elements.Method;
+import com.jetbrains.php.lang.psi.elements.PhpClass;
+import com.jetbrains.php.lang.psi.elements.PhpNamedElement;
+import com.jetbrains.php.lang.psi.elements.StringLiteralExpression;
+import de.espend.idea.php.phpunit.utils.MockeryReferencingUtil;
+import de.espend.idea.php.phpunit.utils.PatternUtil;
+import org.apache.commons.lang.StringUtils;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+public class MockeryAnnotator implements Annotator {
+
+ private enum Scope {
+ PARAMETER(PatternUtil.getMethodReferenceWithParameterPattern(),
+ MockeryReferencingUtil::findMockeryMockParametersOnParameterScope),
+ ARRAY_HASH(PatternUtil.getMethodReferenceWithArrayHashPattern(),
+ MockeryReferencingUtil::findMockeryMockParametersOnArrayHashScope),
+ ARRAY_ELEMENT(PatternUtil.getMethodReferenceWithArrayElementPattern(),
+ MockeryReferencingUtil::findMockeryMockParametersOnArrayElementScope);
+
+ private final PsiElementPattern.Capture<StringLiteralExpression> psiElementPattern;
+ private final Function<StringLiteralExpression, String[]> getMockCreationParametersMethod;
+
+ Scope(PsiElementPattern.Capture<StringLiteralExpression> psiElementPattern, Function<StringLiteralExpression, String[]> getMockCreationParametersMethod) {
+ this.psiElementPattern = psiElementPattern;
+ this.getMockCreationParametersMethod = getMockCreationParametersMethod;
+ }
+
+ public PsiElementPattern.Capture<StringLiteralExpression> getPsiElementPattern() {
+ return psiElementPattern;
+ }
+
+ public String[] getMockCreationParameters(StringLiteralExpression exp) {
+ return getMockCreationParametersMethod.apply(exp);
+ }
+ }
+
+ @Override
+ public void annotate(@NotNull PsiElement psiElement, @NotNull AnnotationHolder annotationHolder) {
+ annotateByScope(Scope.PARAMETER, psiElement, annotationHolder);
+ annotateByScope(Scope.ARRAY_HASH, psiElement, annotationHolder);
+ annotateByScope(Scope.ARRAY_ELEMENT, psiElement, annotationHolder);
+ }
+
+ private void annotateByScope(Scope scope, @NotNull PsiElement psiElement, @NotNull AnnotationHolder annotationHolder) {
+ PsiElementPattern.Capture<StringLiteralExpression> pattern = scope.getPsiElementPattern();
+
+ if (pattern.accepts(psiElement)) {
+ if (psiElement instanceof StringLiteralExpression) {
+ // the method name put as input string in expects/allows etc
+ String contents = ((StringLiteralExpression) psiElement).getContents();
+
+ if (StringUtils.isNotBlank(contents)) {
+ String[] mockCreationParameters = scope.getMockCreationParameters((StringLiteralExpression) psiElement);
+
+ if (mockCreationParameters != null && mockCreationParameters.length > 0) {
+
+ Set<Method> allMethods = new HashSet<>();
+ Set<String> classNames = new HashSet<>();
+ for (String mockCreationParameter : mockCreationParameters) {
+ for (PhpClass phpClass : PhpIndex.getInstance(psiElement.getProject()).getAnyByFQN(mockCreationParameter)) {
+ classNames.add(phpClass.getName());
+
+ allMethods.addAll(phpClass.getMethods().stream()
+ .filter(method -> !method.getAccess().isPublic() || !method.getName().startsWith("__"))
+ .collect(Collectors.toSet())
+ );
+ }
+ }
+
+ Set<String> allMethodNames = allMethods.stream()
+ .map(PhpNamedElement::getName)
+ .collect(Collectors.toSet());
+
+ Set<String> privateMethodNames = allMethods.stream()
+ .filter(method -> method.getAccess().isPrivate())
+ .map(PhpNamedElement::getName)
+ .collect(Collectors.toSet());
+
+ Set<String> protectedMethodNames = allMethods.stream()
+ .filter(method -> method.getAccess().isProtected())
+ .map(PhpNamedElement::getName)
+ .collect(Collectors.toSet());
+
+
+ TextRange textRange = psiElement.getTextRange();
+ TextRange annotationTextRange = new TextRange(textRange.getStartOffset() + 1, textRange.getEndOffset() - 1);
+
+ if (!allMethodNames.contains(contents)) {
+ if (classNames.size() == 1) {
+ String className = classNames.toArray()[0].toString();
+ annotationHolder.newAnnotation(HighlightSeverity.WARNING, "Method '" + contents + "' not found in class " + className)
+ .range(annotationTextRange).create();
+ } else {
+ annotationHolder.newAnnotation(HighlightSeverity.WARNING, "Method '" + contents + "' not found in any of classes " + classNames)
+ .range(annotationTextRange).create();
+ }
+ } else if (privateMethodNames.contains(contents)) {
+ annotationHolder.newAnnotation(HighlightSeverity.WARNING, "Method '" + contents + "' is private, Mockery does not support private methods")
+ .range(annotationTextRange).create();
+ } else if (protectedMethodNames.contains(contents)) {
+ annotationHolder.newAnnotation(HighlightSeverity.WARNING, "Method '" + contents + "' is protected. Mocking protected methods is not suggested. Further guidance can be found here http://docs.mockery.io/en/latest/reference/protected_methods.html")
+ .range(annotationTextRange).create();
+ }
+ }
+ }
+ }
+ }
+ }
+}