Add phpspecs as spec for better tests 🚀

.php_cs

@@ -26,9 +26,8 @@ return PhpCsFixer\Config::create()
     ->setFinder(
         PhpCsFixer\Finder::create()
             ->in(__DIR__ . '/src')
-            ->in(__DIR__ . '/tests')
             ->in(__DIR__ . '/spec')
     )
     ->setRiskyAllowed(true)
     ->setUsingCache(false)
-;
+;

composer.json

@@ -22,8 +22,7 @@
     },
     "autoload-dev": {
         "psr-4": {
-            "Proget\\Tests\\PHPStan\\PhpSpec\\": "tests/",
-            "spec\\Proget\\": "spec/Proget/"
+            "spec\\PhpSpec\\": "spec/PhpSpec/"
         }
     },
     "license": "MIT",
@@ -37,7 +36,7 @@
         "check-cs": "php-cs-fixer fix --dry-run --diff",
         "fix-cs": "php-cs-fixer fix",
         "tests": "phpspec run",
-        "stan": "phpstan analyse -l max -c ./phpstan.neon ./src ./tests ./spec",
+        "stan": "phpstan analyse -l max -c ./phpstan.neon ./src ./spec",
         "check": [
             "@check-cs",
             "@stan",

extension.neon

@@ -2,6 +2,12 @@ services:
     -
         class: Proget\PHPStan\PhpSpec\Reflection\ObjectBehaviorMethodsClassReflectionExtension
         tags: [phpstan.broker.methodsClassReflectionExtension]
+    -
+        class: Proget\PHPStan\PhpSpec\Reflection\ObjectBehaviorPropertiesClassReflectionExtension
+        tags: [phpstan.broker.propertiesClassReflectionExtension]
+    -
+        class: Proget\PHPStan\PhpSpec\Type\ObjectBehaviorDynamicMethodReturnTypeExtension
+        tags: [phpstan.broker.dynamicMethodReturnTypeExtension]
 
 extensions:
     phpspec: Proget\PHPStan\PhpSpec\DependencyInjection\CollaboratorExtension

spec/PhpSpec/CodeAnalysis/MagicAwareAccessInspectorSpec.php

@@ -0,0 +1,99 @@
+<?php
+
+declare(strict_types=1);
+
+namespace spec\PhpSpec\CodeAnalysis;
+
+use PhpSpec\CodeAnalysis\AccessInspector;
+use PhpSpec\ObjectBehavior;
+
+class MagicAwareAccessInspectorSpec extends ObjectBehavior
+{
+    public function let(AccessInspector $accessInspector)
+    {
+        $this->beConstructedWith($accessInspector);
+    }
+
+    public function it_should_be_an_access_inspector()
+    {
+        $this->shouldImplement('PhpSpec\CodeAnalysis\AccessInspector');
+    }
+
+    public function it_should_detect_a_magic_getter_if_no_value_is_given()
+    {
+        $this->isPropertyReadable(new ObjectWithMagicGet, 'property')->shouldReturn(true);
+    }
+
+    public function it_should_detect_a_magic_setter_if_a_value_is_given()
+    {
+        $this->isPropertyWritable(new ObjectWithMagicSet, 'property', true)->shouldReturn(true);
+    }
+
+    public function it_should_detect_a_magic_call_method()
+    {
+        $this->isMethodCallable(new ObjectWithMagicCall, 'method')->shouldreturn(true);
+    }
+
+    public function it_should_not_detect_a_getter_if_there_is_no_magic_getter_and_wrapped_inspector_finds_none(AccessInspector $accessInspector)
+    {
+        $accessInspector->isPropertyReadable(new \stdClass(), 'foo')->willReturn(false);
+
+        $this->isPropertyReadable(new \stdClass(), 'foo')->shouldReturn(false);
+    }
+
+    public function it_should_detect_a_getter_if_there_is_no_magic_getter_but_wrapped_inspector_finds_one(AccessInspector $accessInspector)
+    {
+        $accessInspector->isPropertyReadable(new \stdClass(), 'foo')->willReturn(true);
+
+        $this->isPropertyReadable(new \stdClass(), 'foo')->shouldReturn(true);
+    }
+
+    public function it_should_not_detect_a_setter_if_there_is_no_magic_setter_and_wrapped_inspector_finds_none(AccessInspector $accessInspector)
+    {
+        $accessInspector->isPropertyWritable(new \stdClass(), 'foo')->willReturn(false);
+
+        $this->isPropertyWritable(new \stdClass(), 'foo')->shouldReturn(false);
+    }
+
+    public function it_should_detect_a_setter_if_there_is_no_magic_setter_but_wrapped_inspector_finds_one(AccessInspector $accessInspector)
+    {
+        $accessInspector->isPropertyWritable(new \stdClass(), 'foo')->willReturn(true);
+
+        $this->isPropertyWritable(new \stdClass(), 'foo')->shouldReturn(true);
+    }
+
+    public function it_should_detect_a_method_if_there_is_no_magic_caller_and_wrapped_inspector_finds_none(AccessInspector $accessInspector)
+    {
+        $accessInspector->isMethodCallable(new \stdClass(), 'foo')->willReturn(false);
+
+        $this->isMethodCallable(new \stdClass(), 'foo')->shouldReturn(false);
+    }
+
+    public function it_should_detect_a_method_if_there_is_no_magic_caller_but_wrapped_inspector_finds_one(AccessInspector $accessInspector)
+    {
+        $accessInspector->isMethodCallable(new \stdClass(), 'foo')->willReturn(true);
+
+        $this->isMethodCallable(new \stdClass(), 'foo')->shouldReturn(true);
+    }
+}
+
+class ObjectWithMagicGet
+{
+    public function __get($name)
+    {
+    }
+}
+
+class ObjectWithMagicSet
+{
+    public function __set($name, $value)
+    {
+    }
+}
+
+class ObjectWithMagicCall
+{
+    public function __call($name, $args)
+    {
+    }
+}

spec/PhpSpec/CodeAnalysis/StaticRejectingNamespaceResolverSpec.php

@@ -0,0 +1,45 @@
+<?php
+
+declare(strict_types=1);
+
+namespace spec\PhpSpec\CodeAnalysis;
+
+use PhpSpec\CodeAnalysis\DisallowedNonObjectTypehintException;
+use PhpSpec\CodeAnalysis\NamespaceResolver;
+use PhpSpec\ObjectBehavior;
+
+class StaticRejectingNamespaceResolverSpec extends ObjectBehavior
+{
+    public function let(NamespaceResolver $namespaceResolver)
+    {
+        $this->beConstructedWith($namespaceResolver);
+    }
+
+    public function it_is_initializable()
+    {
+        $this->shouldHaveType('PhpSpec\CodeAnalysis\NamespaceResolver');
+    }
+
+    public function it_delegates_analysis_to_wrapped_resolver(NamespaceResolver $namespaceResolver)
+    {
+        $this->analyse('foo');
+
+        $namespaceResolver->analyse('foo')->shouldhaveBeenCalled();
+    }
+
+    public function it_delegates_resolution_to_wrapped_resolver(NamespaceResolver $namespaceResolver)
+    {
+        $namespaceResolver->resolve('Bar')->willReturn('Foo\Bar');
+
+        $this->resolve('Bar')->shouldReturn('Foo\Bar');
+    }
+
+    public function it_does_not_allow_resolution_of_non_object_types()
+    {
+        $this->shouldThrow(DisallowedNonObjectTypehintException::class)->duringResolve('int');
+        $this->shouldThrow(DisallowedNonObjectTypehintException::class)->duringResolve('float');
+        $this->shouldThrow(DisallowedNonObjectTypehintException::class)->duringResolve('string');
+        $this->shouldThrow(DisallowedNonObjectTypehintException::class)->duringResolve('bool');
+        $this->shouldThrow(DisallowedNonObjectTypehintException::class)->duringResolve('iterable');
+    }
+}

spec/PhpSpec/CodeAnalysis/TokenizedNamespaceResolverSpec.php

@@ -0,0 +1,128 @@
+<?php
+
+declare(strict_types=1);
+
+namespace spec\PhpSpec\CodeAnalysis;
+
+use PhpSpec\ObjectBehavior;
+
+class TokenizedNamespaceResolverSpec extends ObjectBehavior
+{
+    public function it_is_initializable()
+    {
+        $this->shouldHaveType('PhpSpec\CodeAnalysis\NamespaceResolver');
+    }
+
+    public function it_resolves_types_outside_of_namespaces()
+    {
+        $this->analyse('
+        <?php
+
+        class Foo
+        {
+        }
+        ');
+
+        $this->resolve('Bar')->shouldReturn('Bar');
+        $this->resolve('Bar')->shouldReturn('Bar');
+    }
+
+    public function it_resolves_types_from_current_namespace()
+    {
+        $this->analyse('
+        <?php
+
+        namespace Baz;
+
+        class Foo
+        {
+        }
+
+        ');
+
+        $this->resolve('Foo')->shouldReturn('Baz\Foo');
+        $this->resolve('Bar')->shouldReturn('Baz\Bar');
+    }
+
+    public function it_resolves_types_with_use_statements()
+    {
+        $this->analyse('
+        <?php
+
+        namespace Baz;
+
+        use Boz\Bar;
+
+        class Foo
+        {
+        }
+
+        ');
+
+        $this->resolve('Foo')->shouldReturn('Baz\Foo');
+        $this->resolve('Bar')->shouldReturn('Boz\Bar');
+    }
+
+    public function it_resolves_types_with_use_aliases()
+    {
+        $this->analyse('
+        <?php
+
+        namespace Baz;
+
+        use Boz\Bar as Biz;
+
+        class Foo
+        {
+        }
+
+        ');
+
+        $this->resolve('Foo')->shouldReturn('Baz\Foo');
+        $this->resolve('Biz')->shouldReturn('Boz\Bar');
+    }
+
+    public function it_resolves_types_with_partial_use_statements()
+    {
+        $this->analyse('
+        <?php
+
+        namespace Baz;
+
+        use Boz\Bar;
+
+        class Foo
+        {
+            function it_something(Bar\Baz $boz)
+            {
+            }
+        }
+
+        ');
+
+        $this->resolve('Foo')->shouldReturn('Baz\Foo');
+        $this->resolve('Bar\Baz')->shouldReturn('Boz\Bar\Baz');
+    }
+
+    public function it_resolves_types_from_grouped_use_statements()
+    {
+        $this->analyse('
+        <?php
+
+        namespace Baz;
+
+        use Boz\{Fiz, Buz};
+
+        class Foo
+        {
+            function it_something(Fiz $fiz, Buz $buz)
+            {
+            }
+        }
+
+        ');
+
+        $this->resolve('Fiz')->shouldReturn('Boz\Fiz');
+        $this->resolve('Buz')->shouldReturn('Boz\Buz');
+    }
+}