phpunit 只处理一个文件而不是多个

Question

我的测试文件夹如下所示:

- Tests
- folder
-- classTest.php
- anotherClassTest.php

在我创建 folder/classTest.php 之前，PHPUnit 完美地测试了 anotherClassTest.php 但自从我添加了 folder/classTest.php 它只测试那个，不再测试 anotherClassTest.php。

我的配置是这样的:

<?xml version="1.0" encoding="UTF-8"?>
<phpunit
        strict="true"
        bootstrap="./Tests/Bootstrap.php"
>
    <testsuites>
        <testsuite name="unit">
            <directory>Tests/*</directory>
        </testsuite>
    </testsuites>
    <logging>
        <log type="testdox-html" target="Tests/results.html"/>
    </logging>
    <filter>
        <blacklist>
            <directory suffix=".php">vendor</directory>
        </blacklist>
        <whitelist processUncoveredFilesFromWhitelist="true">
            <directory suffix=".php">Tests/</directory>
        </whitelist>
    </filter>
</phpunit>

这里出了什么问题？

更新:另一个ClassTest.php

<?php
/**
 * Created by PhpStorm.
 * User: chris
 * Date: 15-03-17
 * Time: 14:36
 */

use PHPUnit\Framework\TestCase;

/**
 * Class KeyAgencyGeneralTest
 */
class KeyAgencyGeneralTest
    extends TestCase
{
    /**
     * Test for: \ProcessWire\KeyAgencyGeneral::getModuleInfo
     * Test if method is static
     * @todo improve test; do not make use of reflection class and $method->name ==
     */
    public function testGetModuleInfoIsAStaticMethod()
    {
        $mock = $this->createMock(\ProcessWire\KeyAgencyGeneral::class);
        $refl = new ReflectionClass(get_class($mock));
        $staticMethods = $refl->getMethods(ReflectionMethod::IS_STATIC);

        /** @var ReflectionMethod $method */
        foreach ($staticMethods as $method) {
            if ($method->name == 'getModuleInfo') {
                $this->assertEquals('getModuleInfo', $method->name);
            }
        }
    }

    /**
     * Test for: \ProcessWire\KeyAgencyGeneral::getModuleInfo
     * Test is response is an array
     */
    public function testGetModuleInfoReturnsArray()
    {
        $this->assertInternalType(
            'array',
            \ProcessWire\KeyAgencyGeneral::getModuleInfo()
        );
    }

    /**
     * Test for: \ProcessWire\KeyAgencyGeneral::getModuleInfo
     * Test array for correct keys
     */
    public function testGetModuleInfoContainsRequiredKeys()
    {
        $result = \ProcessWire\KeyAgencyGeneral::getModuleInfo();

        $this->assertArrayHasKey('autoload', $result);
        $this->assertArrayHasKey('href', $result);
        $this->assertArrayHasKey('requires', $result);
        $this->assertArrayHasKey('singular', $result);
        $this->assertArrayHasKey('title', $result);
        $this->assertArrayHasKey('version', $result);
    }

    /**
     * Test for: \ProcessWire\KeyAgencyGeneral::_parseLoadString
     * Test if return value of with correct input is an array
     */
    public function testParseLoadStringReturnsArrayWhenParsingModel()
    {
        $this->assertInternalType(
            'array',
            $this
                ->__getInstance()
                ->_parseLoadString('model', 'KeyAgencyGeneral/abstract')
        );
    }

    /**
     * Get instance of module KeyAgencyGeneral
     *
     * @param bool $reflection return reflection class
     * @return \ProcessWire\KeyAgencyGeneral|ReflectionClass
     */
    private function __getInstance($reflection = false)
    {
        if ($reflection) {
            return new ReflectionClass(\ProcessWire\KeyAgencyGeneral::class);
        }
        return new \ProcessWire\KeyAgencyGeneral();
    }

    /**
     * Test for: \ProcessWire\KeyAgencyGeneral::_getObserver
     * Test if KeyAgencyGeneral_Model_Observer is returned
     */
    public function testGetObserverReturnsCorrectInstance()
    {
        $this->assertInstanceOf(
            \ProcessWire\KeyAgencyGeneral_Model_Observer::class,
            $this
                ->__getReflectionMethod('_getObserver')
                ->invoke($this->__getInstance())
        );
    }

    /**
     * Get method from reflection class
     *
     * @param $method
     * @return ReflectionMethod
     */
    private function __getReflectionMethod($method)
    {
        $method = $this->__getInstance(true)->getMethod($method);
        $method->setAccessible(true);

        return $method;
    }

    /**
     * Test for: \ProcessWire\KeyAgencyGeneral::_parseLoadString
     * Check if array response has the required array keys when loading abstract model
     */
    public function testParseLoadStringContainsRequiredPartsWhenParsingModel()
    {
        $result = $this
            ->__getInstance()
            ->_parseLoadString('model', 'KeyAgencyGeneral/abstract');

        $this->assertArrayHasKey('file', $result);
        $this->assertArrayHasKey('location', $result);
        $this->assertArrayHasKey('className', $result);
    }

    /**
     * Test for: \ProcessWire\KeyAgencyGeneral::_parseLoadString
     * Test if exception is thrown when invalid model is trying to load
     */
    public function testParseLoadStringThrowsExceptionOnInvalidInputStringWhenParsingModel()
    {
        $this->expectException(\Exception::class);
        $this
            ->__getInstance()
            ->_parseLoadString('model', 'KeyAgencyGeneral');
    }

    /**
     * Test for: \ProcessWire\KeyAgencyGeneral::_parseLoadString
     * Test if return value of with correct input is an array
     */
    public function testParseLoadStringReturnsArrayWhenParsingHelper()
    {
        $this->assertInternalType(
            'array',
            $this
                ->__getInstance()
                ->_parseLoadString('helper', 'KeyAgencyGeneral/abstract')
        );
    }

    /**
     * Test for: \ProcessWire\KeyAgencyGeneral::_parseLoadString
     * Check if array response has the required array keys when loading abstract helper
     */
    public function testParseLoadStringContainsRequiredPartsWhenParsingHelper()
    {
        $result = $this
            ->__getInstance()
            ->_parseLoadString('helper', 'KeyAgencyGeneral/abstract');

        $this->assertArrayHasKey('file', $result);
        $this->assertArrayHasKey('location', $result);
        $this->assertArrayHasKey('className', $result);
    }

    /**
     * Test for: \ProcessWire\KeyAgencyGeneral::_parseLoadString
     * Test if exception is thrown when invalid helper is trying to load
     */
    public function testParseLoadStringThrowsExceptionOnInvalidInputStringWhenParsingHelper()
    {
        $this->expectException(\Exception::class);

        $this
            ->__getInstance()
            ->_parseLoadString('helper', 'KeyAgencyGeneral');
    }

    /**
     * Test for: \ProcessWire\KeyAgencyGeneral::_capitalize
     * Check for capitalized output
     */
    public function testCapitalize()
    {
        $this->assertEquals(
            'This_Is_A_Test_Response',
            $this
                ->__getReflectionMethod('_capitalize')
                ->invoke($this->__getInstance(), 'this_is_a_test_response')
        );
    }

    /**
     * Test for: \ProcessWire\KeyAgencyGeneral::_underscore
     * Check if string is correctly underscored
     */
    public function testUnderscoreWithStringInput()
    {
        $this->assertEquals(
            'this_is_a_test_response',
            $this
                ->__getReflectionMethod('_underscore')
                ->invoke($this->__getInstance(), 'This is a-test.response')
        );
    }

    /**
     * Test for: \ProcessWire\KeyAgencyGeneral::_underscore
     * Check if array is correctly underscored
     */
    public function testUnderscoreWithArrayInput()
    {
        $this->assertEquals(
            'this_is_a_test_response_this_is_a_test_with_an_array',
            $this
                ->__getReflectionMethod('_underscore')
                ->invoke($this->__getInstance(), [
                    'This is a-test.response',
                    'This-is-A.test with.an ArrAy'
                ])
        );
    }

    /**
     * Test for: \ProcessWire\KeyAgencyGeneral::_isFile
     * Check if file exists
     */
    public function testIsFile()
    {
        $this->assertTrue(
            $this->__getReflectionMethod('_isFile')->invoke(
                $this->__getInstance(),
                __FILE__
            )
        );
    }

    /**
     * Test for: \ProcessWire\KeyAgencyGeneral::isAdmin
     * Test if method is only responding to admin pages
     * @todo write test
     */
    public function testIsAdmin()
    {
        $this->assertFalse(
            true,
            false
        );
    }

    /**
     * Test for: \ProcessWire\KeyAgencyGeneral::getPage
     * Test if page is retrievable by null
     */
    public function testGetPageByNull()
    {
        $this->assertInstanceOf(
            \Processwire\Page::class,
            $this->__getReflectionMethod('getPage')->invoke(
                $this->__getInstance(),
                null
            )
        );
    }

    /**
     * Test for: \ProcessWire\KeyAgencyGeneral::getPage
     * Test if page is retrievable by ID
     */
    public function testGetPageById()
    {
        $this->assertInstanceOf(
            \Processwire\Page::class,
            $this->__getReflectionMethod('getPage')->invoke(
                $this->__getInstance(),
                1
            )
        );
    }

    /**
     * Test for: \ProcessWire\KeyAgencyGeneral::getPage
     * Test if page is retrievable by url path
     */
    public function testGetPageByUrlPath()
    {
        $this->assertInstanceOf(
            \Processwire\Page::class,
            $this->__getReflectionMethod('getPage')->invoke(
                $this->__getInstance(),
                '/'
            )
        );
    }

    /**
     * Test for: \ProcessWire\KeyAgencyGeneral::getModuleConfigInputfields
     * Test if method returns instance of \Processwire\InputfieldWrapper
     */
    public function testGetModuleConfigInputfieldsOnInstance()
    {
        $this->assertInstanceOf(
            \ProcessWire\InputfieldWrapper::class,
            $this->__getReflectionMethod('getModuleConfigInputfields')->invoke($this->__getInstance())
        );
    }

    /**
     * Test for: \ProcessWire\KeyAgencyGeneral::getModuleConfigInputfields
     * Test if method returns required fields
     */
    public function testGetModuleConfigInputfieldsOnRequiredFields()
    {
        $this->assertInstanceOf(
            \ProcessWire\InputfieldText::class,
            $this->__getReflectionMethod('getModuleConfigInputfields')
                ->invoke($this->__getInstance())
                ->get(\ProcessWire\KeyAgencyGeneral::OPTION_SITE_TITLE)
        );
        $this->assertInstanceOf(
            \ProcessWire\InputfieldText::class,
            $this->__getReflectionMethod('getModuleConfigInputfields')
                ->invoke($this->__getInstance())
                ->get(\ProcessWire\KeyAgencyGeneral::OPTION_SEO_DESCRIPTION)
        );
        $this->assertInstanceOf(
            \ProcessWire\InputfieldText::class,
            $this->__getReflectionMethod('getModuleConfigInputfields')
                ->invoke($this->__getInstance())
                ->get(\ProcessWire\KeyAgencyGeneral::OPTION_SEO_KEYWORDS)
        );
        $this->assertInstanceOf(
            \ProcessWire\InputfieldCheckbox::class,
            $this->__getReflectionMethod('getModuleConfigInputfields')
                ->invoke($this->__getInstance())
                ->get(\ProcessWire\KeyAgencyGeneral::OPTION_PRODUCT_MAIN_NAVIGATION_CATEGORIES)
        );
        $this->assertInstanceOf(
            \ProcessWire\InputfieldText::class,
            $this->__getReflectionMethod('getModuleConfigInputfields')
                ->invoke($this->__getInstance())
                ->get(\ProcessWire\KeyAgencyGeneral::OPTION_SITE_TITLE)
        );
    }

    /**
     * Test for: \ProcessWire\KeyAgencyGeneral::getDisplayOptions
     * Test if display options does return an array
     */
    public function testGetDisplayOptionsForTypeArray()
    {
        $this->assertInternalType(
            'array',
            $this->__getReflectionMethod('getDisplayOptions')->invoke(
                $this->__getInstance()
            )
        );
    }

    /**
     * Test for: \ProcessWire\KeyAgencyGeneral::getModuleInfo
     * Test array for correct keys
     */
    public function testGetDisplayOptionsContainsRequiredKeys()
    {
        $result = $this->__getReflectionMethod('getDisplayOptions')->invoke(
            $this->__getInstance()
        );

        $this->assertArrayHasKey(1, $result);
        $this->assertArrayHasKey(2, $result);
    }

    /**
     * Test for: \ProcessWire\KeyAgencyGeneral::_isInstalled
     * Test if method returns boolean
     */
    public function testIsInstalled()
    {
        $this->assertInternalType(
            'bool',
            $this->__getReflectionMethod('_isInstalled')->invoke(
                $this->__getInstance(),
                'KeyAgencyGeneral'
            )
        );
        $this->assertInternalType(
            'bool',
            $this->__getReflectionMethod('_isInstalled')->invoke(
                $this->__getInstance(),
                'nonexistingmodule'
            )
        );
    }

    /**
     * Test for: \ProcessWire\KeyAgencyGeneral::_getCurrencyOptions
     * Check if currency options is returning an array
     */
    public function testGetCurrencyOptionsIsArray()
    {
        $mock = $this->getMockBuilder(\ProcessWire\KeyAgencyGeneral::class)
            ->setMethods([
                '_isInstalled'
            ])
            ->getMock();

        $mock// set mock method to return always false and to be called 2 times
        ->expects($this->exactly(2))
            ->method('_isInstalled')
            ->willReturn(false);

        // create reflection class to make private method accessible
        $reflectionClass = new ReflectionClass($mock);
        $reflectionMethod = $reflectionClass->getMethod('_getCurrencyOptions');
        $reflectionMethod->setAccessible(true);

        $this->assertInternalType(
            'array',
            $reflectionMethod->invoke(
                $mock
            )
        );

        $mock// set mock method to return always true
        ->method('_isInstalled')
            ->willReturn(true);

        $this->assertInternalType(
            'array',
            $reflectionMethod->invoke(
                $mock
            )
        );
    }
}

文件夹/classTest.php

<?php
/**
 * Created by PhpStorm.
 * User: chris
 * Date: 16-03-17
 * Time: 10:40
 */
use PHPUnit\Framework\TestCase;

/**
 * Class KeyAgencyGeneral_Helper_AbstractTest
 */
class KeyAgencyGeneral_Helper_AbstractTest
    extends TestCase
{
    /**
     * Get instance of module KeyAgencyGeneral_Helper_Abstract
     *
     * @param bool $reflection Return reflection class when set to true
     * @return \ProcessWire\KeyAgencyGeneral_Helper_Abstract|ReflectionClass
     */
    private function __getInstance($reflection = false)
    {
        if ($reflection) {
            return new ReflectionClass(\ProcessWire\KeyAgencyGeneral_Helper_Abstract::class);
        }
        return new \ProcessWire\KeyAgencyGeneral_Helper_Abstract();
    }

    /**
     * Get method from reflection class
     *
     * @param $method
     * @return ReflectionMethod
     */
    private function __getReflectionMethod($method)
    {
        $method = $this
            ->__getInstance(true)
            ->getMethod($method);
        $method->setAccessible(true);

        return $method;
    }

    /**
     * Test for: \ProcessWire\KeyAgencyGeneral_Helper_Abstract::_getModule
     * Check for correct module instance
     */
    public function testGetModule()
    {
        $this->assertInstanceOf(
            \ProcessWire\KeyAgencyGeneral::class,
            $this->__getReflectionMethod('_getModule')->invoke(
                $this->__getInstance()
            )
        );
    }

    /**
     * Test for: \ProcessWire\KeyAgencyGeneral_Helper_Abstract::getFile
     * Test for file content (string)
     */
    public function testGetFileReturnsStringWhenFileExists()
    {
        $this->assertInternalType(
            'string',
            $this->__getInstance()->getFile('KeyAgencyGeneral/image')
        );
    }

    /**
     * Test for: \ProcessWire\KeyAgencyGeneral_Helper_Abstract::getFile
     * Test for file content (string)
     */
    public function testGetFileReturnsStringWhenFileDoesNotExist()
    {
        $this->assertInternalType(
            'string',
            $this->__getInstance()->getFile('ThisDoesNot/exist')
        );
    }
}

Answer 1

你有

<testsuite name="unit">
            <directory>Tests/*</directory>        
</testsuite>

这个目录下是你的文件吗？