แนวทางปฏิบัติที่ดีที่สุดในการทดสอบวิธีการป้องกันด้วย PHPUnit

ฉันพบการสนทนาในคุณทดสอบข้อมูลส่วนตัว

ฉันได้ตัดสินใจแล้วว่าในบางชั้นฉันต้องการได้รับวิธีการป้องกัน แต่ทดสอบพวกเขา วิธีการเหล่านี้บางวิธีคงที่และสั้น เนื่องจากวิธีการส่วนใหญ่ของสาธารณชนใช้ประโยชน์จากมันฉันอาจจะสามารถลบการทดสอบในภายหลังได้อย่างปลอดภัย แต่สำหรับการเริ่มต้นด้วยวิธี TDD และหลีกเลี่ยงการดีบักฉันต้องการทดสอบพวกเขาจริงๆ

ฉันคิดถึงสิ่งต่อไปนี้:

• Object Objectที่ได้รับคำแนะนำในคำตอบนั้นดูเหมือนจะเกินกำลังสำหรับเรื่องนี้
• เริ่มต้นด้วยวิธีการสาธารณะและเมื่อรหัสครอบคลุมจะได้รับจากการทดสอบระดับที่สูงขึ้นให้เปิดการป้องกันและลบการทดสอบ
• สืบทอดคลาสที่มีส่วนต่อประสานที่ทดสอบได้ซึ่งทำให้วิธีการป้องกันเป็นแบบสาธารณะ

แนวปฏิบัติที่ดีที่สุดคืออะไร มีอะไรอีกไหม?

ดูเหมือนว่า JUnit จะเปลี่ยนวิธีการป้องกันโดยอัตโนมัติเพื่อให้เป็นแบบสาธารณะ แต่ฉันไม่ได้มองลึกลงไป PHP ไม่ปล่อยให้เรื่องนี้ผ่านการสะท้อน

หากคุณใช้ PHP5 (> = 5.3.2) กับ PHPUnit คุณสามารถทดสอบวิธีการส่วนตัวและการป้องกันโดยใช้การไตร่ตรองเพื่อกำหนดให้เป็นสาธารณะก่อนที่จะทำการทดสอบ:

protected static function getMethod($name) {
  $class = new ReflectionClass('MyClass');
  $method = $class->getMethod($name);
  $method->setAccessible(true);
  return $method;
}

public function testFoo() {
  $foo = self::getMethod('foo');
  $obj = new MyClass();
  $foo->invokeArgs($obj, array(...));
  ...
}

ดูเหมือนว่าคุณจะรู้อยู่แล้ว แต่ฉันจะทำมันต่อไป มันเป็นสัญญาณที่ไม่ดีถ้าคุณต้องการทดสอบวิธีการป้องกัน จุดประสงค์ของการทดสอบหน่วยคือการทดสอบส่วนต่อประสานของชั้นเรียนและวิธีการป้องกันที่มีรายละเอียดการใช้งาน ที่กล่าวว่ามีหลายกรณีที่เหมาะสม หากคุณใช้การสืบทอดคุณสามารถเห็นซูเปอร์คลาสเป็นอินเทอร์เฟซสำหรับคลาสย่อย ดังนั้นที่นี่คุณจะต้องทดสอบวิธีการป้องกัน (แต่ไม่เคยเป็นส่วนตัว ) การแก้ปัญหานี้คือการสร้างคลาสย่อยสำหรับวัตถุประสงค์ในการทดสอบและใช้สิ่งนี้เพื่อเปิดเผยวิธีการ เช่น.:

class Foo {
  protected function stuff() {
    // secret stuff, you want to test
  }
}

class SubFoo extends Foo {
  public function exposedStuff() {
    return $this->stuff();
  }
}

โปรดทราบว่าคุณสามารถแทนที่การสืบทอดด้วยการแต่งเพลงได้ตลอดเวลา เมื่อทำการทดสอบรหัสมักจะง่ายต่อการจัดการกับรหัสที่ใช้รูปแบบนี้ดังนั้นคุณอาจต้องการพิจารณาตัวเลือกนั้น

teastburnมีแนวทางที่ถูกต้อง วิธีที่ง่ายกว่าคือโทรหาวิธีนี้โดยตรงและคืนคำตอบ:

class PHPUnitUtil
{
  public static function callMethod($obj, $name, array $args) {
        $class = new \ReflectionClass($obj);
        $method = $class->getMethod($name);
        $method->setAccessible(true);
        return $method->invokeArgs($obj, $args);
    }
}

คุณสามารถเรียกสิ่งนี้ได้ง่ายๆในแบบทดสอบของคุณโดย:

$returnVal = PHPUnitUtil::callMethod(
                $this->object,
                '_nameOfProtectedMethod', 
                array($arg1, $arg2)
             );

ฉันต้องการที่จะนำเสนอการเปลี่ยนแปลงเล็กน้อยเพื่อ GetMethod () ที่กำหนดไว้ในคำตอบของ uckelman

รุ่นนี้มีการเปลี่ยนแปลง getMethod () โดยการลบค่าฮาร์ดโค้ดและทำให้การใช้งานง่ายขึ้นเล็กน้อย ฉันขอแนะนำให้เพิ่มลงในคลาส PHPUnitUtil ของคุณดังในตัวอย่างด้านล่างหรือในคลาส PHPUnit_Framework_TestCase ที่ขยายเพิ่มของคุณ

เนื่องจาก MyClass กำลังอินสแตนซ์ anyways และ ReflectionClass สามารถใช้สตริงหรือวัตถุ ...

class PHPUnitUtil {
    /**
     * Get a private or protected method for testing/documentation purposes.
     * How to use for MyClass->foo():
     *      $cls = new MyClass();
     *      $foo = PHPUnitUtil::getPrivateMethod($cls, 'foo');
     *      $foo->invoke($cls, $...);
     * @param object $obj The instantiated instance of your class
     * @param string $name The name of your private/protected method
     * @return ReflectionMethod The method you asked for
     */
    public static function getPrivateMethod($obj, $name) {
      $class = new ReflectionClass($obj);
      $method = $class->getMethod($name);
      $method->setAccessible(true);
      return $method;
    }
    // ... some other functions
}

ฉันยังสร้างฟังก์ชันนามแฝง getProtectedMethod () เพื่อให้ชัดเจนถึงสิ่งที่คาดหวัง แต่สิ่งนั้นขึ้นอยู่กับคุณ

ไชโย!

ฉันคิดว่า troelskn อยู่ใกล้ ฉันจะทำสิ่งนี้แทน:

class ClassToTest
{
   protected function testThisMethod()
   {
     // Implement stuff here
   }
}

จากนั้นให้ใช้สิ่งนี้:

class TestClassToTest extends ClassToTest
{
  public function testThisMethod()
  {
    return parent::testThisMethod();
  }
}

จากนั้นคุณรันการทดสอบกับ TestClassToTest

มันควรจะเป็นไปได้ที่จะสร้างคลาสส่วนขยายดังกล่าวโดยอัตโนมัติโดยการแยกรหัส ฉันจะไม่แปลกใจถ้า PHPUnit มีกลไกดังกล่าวอยู่แล้ว (แม้ว่าฉันยังไม่ได้ตรวจสอบ)

ฉันจะโยนหมวกของฉันเข้าไปในวงแหวนที่นี่:

ฉันใช้แฮ็ค __ Call ด้วยระดับความสำเร็จที่หลากหลาย ทางเลือกที่ฉันใช้คือใช้รูปแบบของผู้เข้าชม:

1: สร้างคลาส stdClass หรือแบบกำหนดเอง (เพื่อบังคับใช้ชนิด)

2: ไพรม์ที่มีเมธอดและอาร์กิวเมนต์ที่ต้องการ

3: ตรวจสอบให้แน่ใจว่า SUT ของคุณมีเมธอด acceptVisitor ซึ่งจะดำเนินการเมธอดด้วยอาร์กิวเมนต์ที่ระบุในคลาสการเยี่ยมชม

4: ฉีดเข้าไปในชั้นเรียนที่คุณต้องการทดสอบ

5: SUT จะฉีดผลลัพธ์ของการดำเนินการไปยังผู้เข้าชม

6: ใช้เงื่อนไขการทดสอบของคุณกับแอตทริบิวต์ผลลัพธ์ของผู้เข้าชม

คุณสามารถใช้ __call () ในแบบทั่วไปเพื่อเข้าถึงวิธีการป้องกัน เพื่อให้สามารถทดสอบชั้นนี้

class Example {
    protected function getMessage() {
        return 'hello';
    }
}

คุณสร้างคลาสย่อยใน ExampleTest.php:

class ExampleExposed extends Example {
    public function __call($method, array $args = array()) {
        if (!method_exists($this, $method))
            throw new BadMethodCallException("method '$method' does not exist");
        return call_user_func_array(array($this, $method), $args);
    }
}

โปรดทราบว่าเมธอด __call () ไม่ได้อ้างอิงคลาสในทางใดทางหนึ่งเพื่อให้คุณสามารถคัดลอกข้างต้นสำหรับแต่ละคลาสด้วยวิธีการป้องกันที่คุณต้องการทดสอบและเพียงแค่เปลี่ยนการประกาศคลาส คุณอาจวางฟังก์ชันนี้ในคลาสพื้นฐานทั่วไป แต่ฉันยังไม่ได้ลอง

ตอนนี้กรณีทดสอบเองจะแตกต่างกันในตำแหน่งที่คุณสร้างวัตถุที่จะทดสอบเท่านั้นการสลับใน ExampleExposed สำหรับตัวอย่าง

class ExampleTest extends PHPUnit_Framework_TestCase {
    function testGetMessage() {
        $fixture = new ExampleExposed();
        self::assertEquals('hello', $fixture->getMessage());
    }
}

ฉันเชื่อว่า PHP 5.3 ช่วยให้คุณใช้การสะท้อนเพื่อเปลี่ยนการเข้าถึงวิธีการโดยตรง แต่ฉันคิดว่าคุณต้องทำเช่นนั้นสำหรับแต่ละวิธี

ฉันขอแนะนำวิธีแก้ไขปัญหาต่อไปนี้สำหรับวิธีแก้ปัญหา / แนวคิดของ "Henrik Paul" :)

คุณรู้ชื่อของวิธีการส่วนตัวในชั้นเรียนของคุณ ตัวอย่างเช่นพวกเขาเป็น _add (), _edit (), _delete () ฯลฯ

ดังนั้นเมื่อคุณต้องการทดสอบจากแง่มุมของการทดสอบหน่วยเพียงแค่เรียกเมธอดส่วนตัวโดยการเติมคำนำหน้าและ / หรือต่อท้ายทั่วไปคำคำ (เช่น _addPhpunit) เพื่อที่ว่าเมื่อ __call () วิธีการถูกเรียก (ตั้งแต่ method _addPhpunit () ไม่ มีอยู่) ของคลาสเจ้าของคุณเพียงแค่ใส่โค้ดที่จำเป็นในเมธอด __call () เพื่อลบคำ / ส่วนต่อท้ายที่นำหน้า / s (Phpunit) จากนั้นจึงเรียกวิธีส่วนตัวที่อนุมานจากที่นั่น นี่เป็นอีกวิธีที่ดีในการใช้เวทมนตร์

ลองดู