cuke4php 0.9.0

data/lib/CucumberSteps.php

@@ -0,0 +1,79 @@
+<?php
+/**
+ * @package Cuke4Php
+ */
+ 
+/**
+ * Base class that all cucumber steps should derive from
+ *
+ * Each step gets a reference to the global variables array provided by the scenario.
+ * This allows steps to save and maintain state over the course of a scenario run.
+ *
+ * This class also inherits PHPUnit assertions, so those can all be used within the context of a
+ * step.  Data providers probably don't work, and really should not be used in any case.
+ * @package Cuke4Php
+ */
+class CucumberSteps extends PHPUnit_Framework_Assert {
+    static private $aMocks = array();
+    protected $aGlobals;
+
+    public function __construct(&$_aGlobals) {
+        $this->aGlobals =& $_aGlobals;
+    }
+
+    public static function markPending($sMessage = "Not Implemented") {
+        self::markTestIncomplete($sMessage);
+    }
+
+    public static function getSubclasses() {
+        $aClasses = array();
+        foreach (get_declared_classes() as $sClassName) {
+            if (is_subclass_of($sClassName, 'CucumberSteps') && (stripos($sClassName,"Mock") === false))
+                    $aClasses[] = $sClassName;
+        }
+        return $aClasses;
+    }
+
+    /**
+     * @param  $sMethod
+     * @return mixed
+     */
+    function invoke($sMethod) {
+        return $this->$sMethod();
+    }
+
+		/**
+     * @static
+     * @param  $sClass
+     * @param  $oMock
+     * @return void
+     *
+     * Allows tests to set mock hooks to be used
+     */
+    static function setMock($sClass, $oMock) {
+        self::$aMocks[$sClass] = $oMock;
+    }
+
+		static function clearMocks() {
+			self::$aMocks = array();
+		}
+
+    /**
+     * @static
+     * @param  $sClass
+     * @param  $aGlobals
+     * @return
+     *
+     * Get an instance of a hook which is either a pre-set mock,
+     * or an instance of the appropriate step class with the globals initialized
+     */
+    static function getInstance($sClass, $aGlobals) {
+        if (array_key_exists($sClass, self::$aMocks) && self::$aMocks[$sClass]) {
+            return self::$aMocks[$sClass];
+        } else {
+            return new $sClass($aGlobals);
+        }
+    }
+}
+
+?>

data/lib/Cuke4Php.php

@@ -0,0 +1,242 @@
+<?php
+/**
+ * @package Cuke4Php
+ */
+
+set_time_limit(0);
+
+
+/**
+ *  Cuke4Php implements the Cucumber wire protocol for PHP
+ *
+ * http://wiki.github.com/aslakhellesoy/cucumber/wire-protocol
+ * @package Cuke4Php
+ */
+class Cuke4Php {
+    public $iPort;
+    private $bRun;
+    private $oSocket;
+    private $oScenario;
+    private $aStepClasses;
+    public $aWorld = array(
+        'steps' => array(),
+        'before' => array(),
+        'after' => array()
+    );
+
+    function __construct($_sFeaturePath, $_iPort = 16816) {
+        if ($_iPort > 0) {
+            $this->iPort = $_iPort;
+        } else {
+            $this->iPort = 16816;
+        }
+
+        foreach (self::rglob("*.php", 0,  $_sFeaturePath . "/support") as $sFilename) {
+            require_once $sFilename;
+        }
+        require_once "Cucumber.php";
+        foreach (self::rglob("*.php", 0,  $_sFeaturePath . "/step_definitions") as $sFilename) {
+            require_once $sFilename;
+        }
+        $this->aStepClasses = CucumberSteps::getSubclasses();
+        foreach ($this->aStepClasses as $sClass) {
+            $oReflection = new ReflectionClass($sClass);
+            $aMethods = $oReflection->getMethods();
+            foreach ($aMethods as $oMethod) {
+                $sComment = $oMethod->getDocComment();
+                $aMatches = array();
+                $aMethod = array();
+                $aMethod['method'] = $oMethod->name;
+                $aMethod['class'] = $oMethod->class;
+                $aMethod['filename'] = $oMethod->getFileName();
+                $aMethod['startline'] = $oMethod->getStartLine();
+                if (substr($oMethod->name, 0, 4) === "step") {
+                    preg_match("/(?:Given|When|Then) (.+)$/im", $sComment, $aMatches);
+                    $aMethod['regexp'] = $aMatches[1];
+                    $this->aWorld['steps'][] = $aMethod;
+                    continue;
+                }
+                preg_match("/(@.+)/im", $sComment, $aMatches);
+                if (array_key_exists(1, $aMatches)) {
+                    $aMethod['tags'] = explode(" ", str_replace("@", "", $aMatches[1]));
+                }
+                if (substr($oMethod->name, 0, 6) === "before") {
+                    $this->aWorld['before'][] = $aMethod;
+                    continue;
+                }
+                if (substr($oMethod->name, 0, 5) === "after") {
+                    $this->aWorld['after'][] = $aMethod;
+                    continue;
+                }
+            }
+        }
+    }
+
+		/**
+		 * @param string $pattern
+		 * @param int $flags
+		 * @param string $path
+		 * @return array
+		 * recursive glob utility function
+		 */
+		static function rglob($sPattern='*', $iFlags = 0, $sPath='') {
+		    $aPaths=glob($sPath.'*', GLOB_MARK|GLOB_ONLYDIR|GLOB_NOSORT);
+		    $aFiles=glob($sPath.$sPattern, $iFlags);
+		    foreach ($aPaths as $sPath) { $aFiles=array_merge($aFiles,self::rglob($sPattern, $iFlags, $sPath)); }
+		    return $aFiles;
+		}
+
+
+    /**
+     * @param  $oScenario
+     * @return void
+     */
+    function setScenario($oScenario) {
+        $this->oScenario = $oScenario;
+    }
+
+    function __destruct() {
+        if (isset($this->oSocket) && $this->oSocket) {
+            socket_close($this->oSocket);
+        }
+    }
+
+    function run() {
+        print "Cuke4Php listening on port $this->iPort\n";
+        $this->oSocket = socket_create_listen($this->iPort);
+        $this->bRun = true;
+        while ($this->bRun && ($connection = socket_accept($this->oSocket))) {
+            socket_getpeername($connection, $raddr, $rport);
+            while ($this->bRun && ($input = socket_read($connection, 1024 * 4))) {
+                $data = trim($input);
+                if ($data !== "") {
+                    $output = json_encode($this->process($data)) . "\n";
+										if ($this->bRun) {
+	                    socket_write($connection, $output);											
+										}
+                }
+            }
+            socket_close($connection);
+            sleep(1);
+        }
+    }
+
+    function process($sInput) {
+        switch ($sInput) {
+            case "quit":
+            case "bye":
+                $this->bRun = false;
+                return "Complete";
+                break;
+            default:
+                $aCommand = json_decode($sInput);
+                $sAction = $aCommand[0];
+                $sData = NULL;
+                if (array_key_exists(1, $aCommand)) {
+                    $sData = $aCommand[1];
+                }
+                switch ($sAction) {
+                    case 'begin_scenario':
+                        return $this->beginScenario($sData->tags);
+                        break;
+                    case 'step_matches':
+                        return $this->stepMatches($sData->name_to_match);
+                        break;
+                    case 'invoke':
+                        return $this->oScenario->invoke($sData->id, $sData->args);
+                        break;
+                    case 'end_scenario':
+                        return $this->endScenario($sData->tags);
+                        break;
+                    case 'snippet_text':
+                        return $this->snippetText($sData);
+                    default:
+                        print "Unknown Command: $sInput\n";
+                        break;
+                }
+                return array('success');
+                break;
+        }
+    }
+
+    /**
+     * @param  $aTags
+     * @return array
+     * run any before hooks for a scenario
+     */
+    function beginScenario($aTags) {
+        $this->setScenario(CucumberScenario::getInstance($this->aWorld));
+        return $this->oScenario->invokeBeforeHooks($aTags);
+    }
+
+    /**
+     * @param  $sStep
+     * @return array
+     * when given a string, this method will return information about any step that matches it
+     */
+    function stepMatches($sStep) {
+        $aSteps = array();
+        for ($i = 0; $i < count($this->aWorld['steps']); $i++) {
+            $aMatches = array();
+            $aStep = $this->aWorld['steps'][$i];
+            if (preg_match_all($aStep['regexp'], $sStep, $aMatches, PREG_OFFSET_CAPTURE)) {
+                $aArgs = array();
+                array_shift($aMatches);
+                foreach ($aMatches as $aMatch) {
+                    $aArgs[] = array('val' => $aMatch[0][0], 'pos' => $aMatch[0][1]);
+                }
+                $aSteps[] = array('id' => $i, 'args' => $aArgs, 'source' => $aStep['filename'] . ":" . $aStep['startline']);
+            };
+        }
+        return array('success', $aSteps);
+    }
+
+    /**
+     * @param  $aTags
+     * @return array
+     * run any after hooks for a scenario
+     */
+    function endScenario($aTags) {
+        $oResult = $this->oScenario->invokeAfterHooks($aTags);
+        $this->oScenario = null;
+        return $oResult;
+    }
+
+    /**
+     * @param  $aSnippet
+     * @return array
+     * return a template for an undefined step
+     */
+    function snippetText($aSnippet) {
+        $sMethodName = "step" . str_replace(" ", "", ucwords(preg_replace("/\W+/", " ", preg_replace("/\"[^\"]*\"/", "Parameter", $aSnippet->step_name))));
+        $count = 0;
+        $aParams = array();
+        $sStepName = preg_replace("/\"[^\"]*\"/", "\"([^\"]*)\"", preg_quote($aSnippet->step_name), -1, &$count);
+        for ($param = 1; $param <= $count; $param++) {
+            $aParams[] = "\$arg$param";
+        }
+        switch ($aSnippet->multiline_arg_class) {
+            case "Cucumber::Ast::Table":
+                $aParams[] = "\$aTable";
+                break;
+            case "Cucumber::Ast::PyString":
+                $aParams[] = "\$sString";
+                break;
+            default:
+        }
+
+        $sParams = implode(",", $aParams);
+        $sMethodBody = <<<EOT
+
+/**
+* {$aSnippet->step_keyword} /^$sStepName$/
+**/
+public function $sMethodName($sParams) {
+    self::markPending();
+}
+EOT;
+        return array('success', $sMethodBody);
+    }
+}
+
+?>

data/php_bin/cuke4php_server

@@ -0,0 +1,20 @@
+#!/usr/bin/env php
+<?php
+/**
+ * main entry point for starting a Cuke4Php wire server
+ * @package Cuke4Php
+ */
+
+/**
+ * load the Cuke4Php server
+ */
+require_once dirname(__FILE__) . "/../lib/Cuke4Php.php";
+$aOptions = getopt("p:");
+if (array_key_exists('p',$aOptions)) {
+    $iPort = $aOptions['p'];
+} else {
+    $iPort = null;
+}
+$oServer = new Cuke4Php(realpath($argv[$argc-1]), $iPort);
+$oServer->run();
+?>

data/tests/lib/CucumberScenarioTest.php

@@ -0,0 +1,161 @@
+<?php
+/**
+ * @package Cuke4Php
+ */
+
+/**
+ * load Cucumber php framework
+ */
+require_once dirname(__FILE__) . "/../../lib/Cucumber.php";
+
+/**
+ * class TestException
+ * this class is used during the tests to mock exceptions.
+ * @package Cuke4Php
+ */
+class TestException extends Exception {
+    public function __toString() {
+        return "TestException";
+    }
+}
+
+require_once(dirname(__FILE__) . "/../../features/step_definitions/TestSteps.php");
+
+/**
+ * class CucumberScenarioTest
+ * @package Cuke4Php
+ */
+class CucumberScenarioTest extends PHPUnit_Framework_TestCase {
+
+    public $oScenario;
+    public $aWorld;
+    public $aTags;
+    public $oMockHook;
+
+    public function setup() {
+        CucumberSteps::clearMocks();
+        $this->aWorld = array(
+            'before' => array(
+                array(
+                    'tags' => array('one'),
+                    'class' => 'TestSteps',
+                    'method' => 'beforeWithOneTag'
+                     ),
+                array(
+                    'tags' => array(),
+                    'class' => 'TestSteps',
+                    'method' => 'beforeWithNoTags'
+                )
+            ),
+            'after' => array(
+                array(
+                    'tags' => array('one'),
+                    'class' => 'TestSteps',
+                    'method' => 'afterWithOneTag'
+                     ),
+                array(
+                    'tags' => array(),
+                    'class' => 'TestSteps',
+                    'method' => 'afterWithNoTags'
+                )
+            ),
+            'steps' => array(
+                0 => array(
+                    'class' => 'TestSteps',
+                    'method' => 'stepSuccessful'
+                    ),
+                1 => array(
+                    'class' => 'TestSteps',
+                    'method' => 'stepIncomplete'
+                    ),
+                2 => array(
+                    'class' => 'TestSteps',
+                    'method' => 'stepSkipped'
+                    ),
+                3 => array(
+                    'class' => 'TestSteps',
+                    'method' => 'stepPending'
+                    ),
+                4 => array(
+                    'class' => 'TestSteps',
+                    'method' => 'stepFailed'
+                    ),
+                5 => array(
+                    'class' => 'TestSteps',
+                    'method' => 'stepException'
+                    ),
+                6 => array(
+                    'class' => 'TestSteps',
+                    'method' => 'stepNotEqual'
+                )
+
+            )
+
+        );
+        $this->aTags = array('one','two');
+        $this->oScenario = new CucumberScenario($this->aWorld);
+        $this->oMockHook = $this->getMock('TestSteps', array(
+            'beforeWithOneTag',
+            'beforeWithNoTags',
+            'afterWithOneTag',
+            'afterWithNoTags'), array(array()));
+    }
+
+    public function testShouldRunBeforeHooksWithAMatchingTag() {
+        $this->oMockHook->expects(self::once())->method('beforeWithOneTag');
+        $this->oMockHook->expects(self::once())->method('beforeWithNoTags');
+        CucumberSteps::setMock('TestSteps', $this->oMockHook);
+        self::assertEquals(array('success'),$this->oScenario->invokeBeforeHooks($this->aTags));
+    }
+
+    public function testShouldRunBeforeHooksWithNoTags() {
+        $this->oMockHook->expects(self::once())->method('beforeWithNoTags');
+        CucumberSteps::setMock('TestSteps', $this->oMockHook);
+        self::assertEquals(array('success'),$this->oScenario->invokeBeforeHooks(array()));
+    }
+
+
+    public function testShouldRunAfterHooksWithAMatchingTag() {
+        $this->oMockHook->expects(self::once())->method('afterWithOneTag');
+        $this->oMockHook->expects(self::once())->method('afterWithNoTags');
+        CucumberSteps::setMock('TestSteps', $this->oMockHook);
+        self::assertEquals(array('success'),$this->oScenario->invokeAfterHooks($this->aTags));
+    }
+
+    public function testShouldRunAfterHooksWithNoTags() {
+        $this->oMockHook->expects(self::once())->method('afterWithNoTags');
+        CucumberSteps::setMock('TestSteps', $this->oMockHook);
+        self::assertEquals(array('success'),$this->oScenario->invokeAfterHooks(array()));
+    }
+
+    public function testInvokeShouldReturnSuccess() {
+        self::assertEquals(array('success'),$this->oScenario->invoke(0,array()));
+    }
+
+    public function testInvokeShouldReturnPendingWhenIncomplete() {
+        self::assertEquals(array('pending','incomplete'),$this->oScenario->invoke(1,array()));
+    }
+
+    public function testInvokeShouldReturnPendingWhenSkipped() {
+        self::assertEquals(array('pending','skipped'),$this->oScenario->invoke(2,array()));
+    }
+
+    public function testInvokeShouldReturnPendingWhenPending() {
+        self::assertEquals(array('pending','pending'),$this->oScenario->invoke(3,array()));
+    }
+
+    public function testInvokeShouldFailWhenAssertionNotMet() {
+        self::assertEquals(array('fail',array('message' => 'Failed asserting that <boolean:false> is equal to <boolean:true>.')), $this->oScenario->invoke(4,array()));
+    }
+
+    public function testInvokeShouldFailWhenExceptionThrown() {
+        self::assertEquals(array('fail',array('exception' => 'TestException')), $this->oScenario->invoke(5,array()));
+    }
+
+    public function testInvokeShouldSucceedWithParameters() {
+        self::assertEquals(array('success'), $this->oScenario->invoke(6,array('one','two')));
+    }
+
+}
+
+?>

data/tests/lib/Cuke4PhpTest.php

@@ -0,0 +1,117 @@
+<?php
+/**
+ * @package Cuke4Php
+ */
+ 
+/**
+ * load Cucumber framework
+ */
+require_once dirname(__FILE__) . "/../../lib/Cucumber.php";
+
+/**
+ * @package Cuke4Php
+ */
+class Cuke4PhpTest extends PHPUnit_Framework_TestCase {
+
+    public $oCuke4Php;
+
+    function setup() {
+        $this->oCuke4Php = new Cuke4Php(dirname(__FILE__) . "/../../features");
+    }
+
+    function testSnippetTextReturnsSnippet() {
+        $oSnippet = new StdClass;
+        $oSnippet->step_name = "this is a step name";
+				$oSnippet->multiline_arg_class = "";
+				$oSnippet->step_keyword = "Given";
+        $sActual = $this->oCuke4Php->snippetText($oSnippet);
+        $sExpected = array('success',"
+/**
+* Given /^this is a step name$/
+**/
+public function stepThisIsAStepName() {
+    self::markPending();
+}");
+        self::assertEquals($sExpected, $sActual);
+    }
+
+    function testSnippetTextReturnsSnippetWithParameters() {
+        $oSnippet = new StdClass;
+        $oSnippet->step_name = 'this is a step with parameter "param1"';
+				$oSnippet->multiline_arg_class = "";
+				$oSnippet->step_keyword = "Given";
+        $sActual = $this->oCuke4Php->snippetText($oSnippet);
+        $sExpected = array('success','
+/**
+* Given /^this is a step with parameter "([^"]*)"$/
+**/
+public function stepThisIsAStepWithParameterParameter($arg1) {
+    self::markPending();
+}');
+        self::assertEquals($sExpected, $sActual);
+    }
+
+    function testSnippetTextReturnsSnippetWithATable() {
+        $oSnippet = new StdClass;
+        $oSnippet->step_name = 'this is a step with a table:';
+        $oSnippet->multiline_arg_class = "Cucumber::Ast::Table";
+				$oSnippet->step_keyword = "Given";
+        $sActual = $this->oCuke4Php->snippetText($oSnippet);
+        $sExpected = array('success','
+/**
+* Given /^this is a step with a table\:$/
+**/
+public function stepThisIsAStepWithATable($aTable) {
+    self::markPending();
+}');
+        self::assertEquals($sExpected, $sActual);
+    }
+
+    function testSnippetTextReturnsSnippetWithAMultilineString() {
+        $oSnippet = new StdClass;
+        $oSnippet->step_name = 'this is a step with a pystring:';
+        $oSnippet->multiline_arg_class = "Cucumber::Ast::PyString";
+				$oSnippet->step_keyword = "Given";
+        $sActual = $this->oCuke4Php->snippetText($oSnippet);
+        $sExpected = array('success','
+/**
+* Given /^this is a step with a pystring\:$/
+**/
+public function stepThisIsAStepWithAPystring($sString) {
+    self::markPending();
+}');
+        self::assertEquals($sExpected, $sActual);
+    }
+
+    function testBeginScenarioShouldInvokeBeforeHooks() {
+        $oMockScenario = $this->getMock('CucumberScenario', array('invokeBeforeHooks'));
+        $oMockScenario->expects(self::once())->method('invokeBeforeHooks');
+        CucumberScenario::setInstance($oMockScenario);
+        $this->oCuke4Php->beginScenario(array());
+    }
+
+    function testEndScenarioShouldInvokeAfterHooks() {
+        $oMockScenario = $this->getMock('CucumberScenario', array('invokeAfterHooks'));
+        $oMockScenario->expects(self::once())->method('invokeAfterHooks');
+        $this->oCuke4Php->setScenario($oMockScenario);
+        $this->oCuke4Php->endScenario(array());
+    }
+
+    function testStepMatchesShouldReturnEmptySetWhenNoMatches() {
+        self::assertEquals(array('success',array()), $this->oCuke4Php->stepMatches("random step"));
+    }
+
+    function testStepMatchesShouldReturnMatches() {
+        self::assertEquals(array('success',array(
+            array('id' => 0, 'args' => array(), 'source' => realpath(dirname(__FILE__) . '/../../features/step_definitions/TestSteps.php') . ":14")            
+        )), $this->oCuke4Php->stepMatches("successful"));
+    }
+
+    function testStepMatchesShouldReturnMatchesWithParameters() {
+        self::assertEquals(array('success',array(
+            array('id' => 6, 'args' => array(), 'source' => realpath(dirname(__FILE__) . '/../../features/step_definitions/TestSteps.php') . ":54")
+        )), $this->oCuke4Php->stepMatches('"arg1" not equal to "arg2"'));
+    }
+
+}
+?>