cuke4php 0.9.2 → 0.9.3

data/HISTORY

@@ -2,4 +2,14 @@
   * first gem release
   
 2011-01-27 -- 0.9.1
-  * allow cuke4php to accept a feature filename instead of a path name so users can run just one feature file at a time
+  * allow cuke4php to accept a feature filename instead of a path name so users can run just one feature file at a time
+  
+2011-01-27 -- 0.9.2
+  * fix a bug preventing use by just passing a directory name
+  
+2011-01-28
+  * trap and handle php errors, convert them to exceptions and then let them bubble up as usual.
+
+2011-01-30
+  * use magic setters and getters to allow assignment and retrieval of properties on steps
+  * implement step argument transformations

data/README.md

@@ -33,6 +33,7 @@ Roadmap
 
 * support an option like 'cuke4php --init' which will generate the directory structure and support files necessary to use cuke4php with a php project.
 * autodetect an available port and then use it to run the cuke4php server pass this on to cucumber by setting an environment variable (requires a modification to cucumber)
+* lint check all php files in features directory before starting the cuke4php server
 
 ### Gemfile
 

data/VERSION

@@ -1 +1 @@
-0.9.2
+0.9.3

data/bin/cuke4php

@@ -5,6 +5,8 @@
 # TODO: autodetect an available port and then use it to run the cuke4php server pass this on to cucumber by setting an environment variable (requires a modification to cucumber)
 # see https://github.com/olbrich/cucumber/commit/0c11d206e08e8d5647e03bf78be93723d59529ef
 
+# TODO: lint check all php files before starting the cuke4php server
+
 # Note that changing the port number currently requires updating the Cuke4Php.wire file in your project's step_definitions
 # or cucumber will look for the cuke4php server on the wrong port.
 CUKE4PHP_PORT=ENV['CUKE4PHP_PORT'] || 16816

data/cuke4php.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{cuke4php}
-  s.version = "0.9.2"
+  s.version = "0.9.3"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Kevin Olbrich", "Alessandro Dal Grande"]
-  s.date = %q{2011-01-27}
+  s.date = %q{2011-03-23}
   s.default_executable = %q{cuke4php}
   s.description = %q{Using this protocol it is possible to directly interact with PHP code at any level without the need for a web server.  To accomplish this, when cucumber is running against a directory containing feature files and it cannot resolve a particular step definition, it will ask a known wire server (as defined in a .wire file) to interpret and run those steps.}
   s.email = ["kevin.olbrich+cuke4php@gmail.com", "aledalgrande@gmail.com"]
@@ -30,10 +30,12 @@ Gem::Specification.new do |s|
     "cucumber.yml",
     "cuke4php.gemspec",
     "features/Cuke4Php.feature",
+    "features/scenario.feature",
     "features/step_definitions/Cuke4Php.wire",
     "features/step_definitions/TestSteps.php",
     "features/step_definitions/WireSteps.php",
     "features/support/Env.php",
+    "features/transform.feature",
     "lib/Cucumber.php",
     "lib/CucumberScenario.php",
     "lib/CucumberSteps.php",

data/features/Cuke4Php.feature

@@ -40,3 +40,18 @@ Scenario Outline: run several steps many times
     | shoot      | messenger | dead      |
     | understand | meaning   | clear     |
 
+@error    
+Scenario Outline: Error Handling
+  When an error "<error_constant>" with message "<error_message>" occurs
+  Then an "<exception>" should be caught
+  
+  Examples:
+    | error_constant | error_message         | exception                       |
+    | E_USER_ERROR   | an error has occurred | PHPUnit_Framework_Error         |
+    | E_USER_WARNING | a warning message     | PHPUnit_Framework_Error_Warning |
+    | E_USER_NOTICE  | a notice message      | PHPUnit_Framework_Error_Notice  |
+
+@exception
+Scenario: Exception Handling
+  When an "Exception" is thrown with message "generic exception"
+  Then an "Exception" should be caught  

data/features/scenario.feature

@@ -0,0 +1,45 @@
+Feature: Scenarios
+
+Scenario Outline: I save values as properties and use them again later
+  Given I store "<value>" into "<value>"
+  Then "<value>" should equal "<value>"
+  
+  Examples:
+    | value       |
+    | !           |
+    | @           |
+    | #           |
+    | $           |
+    | %           |
+    | ^           |
+    | &           |
+    | *           |
+    | (           |
+    | )           |
+    | -           |
+    | =           |
+    | ()          |
+    | with spaces |
+    | $sVar       |
+    
+Scenario: I save an array as a property
+  Given "value" is:
+    | key  | value  |
+    | key1 | value1 |
+    | key2 | value2 |
+  Then "value" should be set
+  Then "non-value" should not be set
+  And "value" should equal:
+    | key  | value  |
+    | key1 | value1 |
+    | key2 | value2 |
+
+Scenario: I unset a property
+  Given I store "Foo" into "Bar"
+  When I unset "Bar"
+  Then "Bar" should not be set
+
+Scenario: I try to read a property that was not set first
+  Given "Foo" should not be set
+  Then getting "Foo" should raise an "PHPUnit_Framework_Error"
+  

data/features/step_definitions/TestSteps.php

@@ -45,7 +45,7 @@ class TestSteps extends CucumberSteps {
      * Given /^an exception is thrown$/
      */
     public function stepException() {
-        throw new TestException('Exception');
+        throw new Exception('test exception');
     }
 
     /**

data/features/step_definitions/WireSteps.php

@@ -11,7 +11,7 @@ class WireSteps extends CucumberSteps {
      * @wire
      */
     function beforeWire() {
-        $this->aGlobals['before'] = 'beforeWire';
+        $this->before = 'beforeWire';
     }
 
     function beforeAll() {
@@ -81,7 +81,137 @@ class WireSteps extends CucumberSteps {
 
     }
 
+    /**
+    * When /^an error "([^"]*)" with message "([^"]*)" occurs$/
+    **/
+    public function stepAnErrorParameterWithMessageParameterOccurs($sType,$sMessage) {
+      try {
+        trigger_error($sMessage, constant($sType));        
+      } catch (Exception $e) {
+        $this->exception = $e;
+      }
+    }
+
+    /**
+    * When /^an? "([^"]*)" is thrown with message "([^"]*)"$/
+    **/
+    public function stepAnExceptionParameterIsThrownWithMessageParameter($sExceptionClass,$sMessage) {
+        try {
+          throw new $sExceptionClass($sMessage);
+        } catch (Exception $e) {
+          $this->exception = $e;
+        }
+    }
+
+    /**
+    * Then /^an? "([^"]*)" should be caught$/
+    **/
+    public function stepAParameterExceptionShouldBeCaught($sExceptionType) {
+      self::assertInstanceOf($sExceptionType, $this->exception);
+    }
+
+    /**
+    * Given /^I store "([^"]*)" into "([^"]*)"$/
+    **/
+    public function stepIStoreParameterIntoParameter($sValue,$sKey) {
+        $this->$sKey = $sValue;
+    }
+
+
+    /**
+    * Then /^"([^"]*)" should equal "([^"]*)"$/
+    **/
+    public function stepParameterShouldEqualParameter($sKey,$sValue) {
+        self::assertEquals($sValue, $this->$sKey);
+    }
+
+    /**
+    * When /^I unset "([^"]*)"$/
+    **/
+    public function stepIUnsetParameter($sKey) {
+        unset($this->$sKey);
+    }
+
+    /**
+    * Then /^"([^"]*)" (should|should not) be set$/
+    **/
+    public function stepParameterShouldBeSet($sKey, $sShould) {
+      self::assertEquals(($sShould == "should"), isset($this->$sKey));
+    }
+    
+    /**
+    * Given /^"([^"]*)" is\:$/
+    **/
+    public function stepParameterIs($sKey,$aTable) {
+      array_shift($aTable); // peel off the table column headings
+      $this->$sKey = $aTable;
+    }
 
+    /**
+    * Then /^"([^"]*)" should equal\:$/
+    **/
+    public function stepParameterShouldEqual($sKey,$aTable) {
+      array_shift($aTable); // peel off the table column headings
+      self::assertEquals($aTable, $this->$sKey);
+    }
+  
+    /**
+    * Then /^getting "([^"]*)" should raise an? "([^"]*)"$/
+    **/
+    public function stepGettingParameterShouldRaiseAnParameter($sKey, $sExceptionClass) {
+        unset($this->exception);
+        try {
+          $this->$sKey;
+          self::fail("No Exception Caught");
+        } catch (Exception $e) {
+          $this->exception = $e;
+        }
+        self::assertInstanceOf($sExceptionClass, $this->exception);
+    }
+    
+    /**
+    * Transform /^(\d+)$/
+    **/
+    public function transformToInteger($sArg) {
+      return intval($sArg);
+    }
+
+    /**
+    * Transform /^(abcd)$/
+    **/
+    public function transformReverse($sArg) {
+      return "dcba";
+    }
+
+    /**
+    * Transform /^(abcd)$/
+    **/
+    public function transformCapitalize($sArg) {
+      return "ABCD";
+    }
+    
+    /**
+    * Transform /^\{(.*)\}$/
+    **/
+    public function transformSubstituteValues($sArg) {
+      return $this->$sArg;
+    }
+    
+    /**
+    * Transform /^table:reverse$/
+    **/
+    public function transformReverseTable($aTable) {
+      return array_reverse($aTable);
+    }
+    
+
+    /**
+    * Then /^"([^"]*)" should be a kind of "([^"]*)"$/
+    **/
+    public function stepParameterShouldBeAKindOfParameter($sKey,$sTypeName) {
+        self::assertInternalType($sTypeName, $this->$sKey);
+    }
+    
 }
 
 ?>

data/features/transform.feature

@@ -0,0 +1,30 @@
+Feature: Argument Transformation
+  As a user of cuke4php
+  I want to use step argument transforms
+  So that I can simplify my code
+  Example transforms can be found in WireSteps.php
+  
+Scenario: An argument is transformed to an integer
+  Given I store "123" into "Foo"
+  Then "Foo" should be a kind of "integer"
+  
+Scenario: use a transform to substitute variable in arguments
+  Given I store "foo" into "Bar"
+  And I store "{Bar}" into "Foo"
+  Then "Foo" should equal "foo"
+  
+Scenario: An argument is transformed, but the second defined transform wins
+  Given I store "abcd" into "Foo"
+  Then "Foo" should equal "ABCD"
+
+Scenario: transform a table
+  Given "table" is:
+    | reverse |
+    | one |
+    | two |
+    | three |
+  Then "table" should equal:
+    | reverse |
+    | three |
+    | two |
+    | one |

data/lib/CucumberScenario.php

@@ -58,38 +58,46 @@ class CucumberScenario {
      * @return array
      * invokes all the before hooks defined that either have no tags or tags corresponding to this scenario's tags
      */
-    function invokeBeforeHooks($aTags) {
-        foreach ($this->aWorld['before'] as $aBeforeHook) {
-			if (array_key_exists('tags', $aBeforeHook))
-            	if (count($aBeforeHook['tags']) == 0 || count(array_intersect($aTags, $aBeforeHook['tags'])) > 0) {
-                    $oStep = CucumberSteps::getInstance($aBeforeHook['class'], $this->aGlobals);
-                    $oResult = $oStep->invoke($aBeforeHook['method']);
-                    if ($oResult === false) {
-                        return array('failure');
-                    }
-            	}
-        }
-        return array('success');
-    }
+     function invokeBeforeHooks($aTags) {
+       if (is_null($aTags)) {
+         $aTags = array();
+       }
+       foreach ($this->aWorld['before'] as $aBeforeHook) {
+         if (array_key_exists('tags', $aBeforeHook)) {
+           if (count($aBeforeHook['tags']) == 0 || count(array_intersect($aTags, $aBeforeHook['tags'])) > 0) {
+             $oStep = CucumberSteps::getInstance($aBeforeHook['class'], $this->aGlobals);
+             $oResult = $oStep->invoke($aBeforeHook['method']);
+             if ($oResult === false) {
+               return array('failure');
+             }
+           }
+         }
+       }
+       return array('success');
+     }
 
     /**
      * @param  $aTags
      * @return array
      * invoke all after hooks defined that either have no tags, or tags that match the tags of the current scenario
      */
-    function invokeAfterHooks($aTags) {
-        foreach ($this->aWorld['after'] as $aAfterHook) {
-			if (array_key_exists('tags', $aAfterHook))
-	            if (count($aAfterHook['tags']) == 0 || count(array_intersect($aTags, $aAfterHook['tags'])) > 0) {
-	                $oStep = CucumberSteps::getInstance($aAfterHook['class'], $this->aGlobals);
-	                $oResult = $oStep->invoke($aAfterHook['method']);
-	                if ($oResult === false) {
-	                    return array('failure');
-	                }
-	            }
-        }
-        return array('success');
-    }
+     function invokeAfterHooks($aTags) {
+       if (is_null($aTags)) {
+         $aTags = array();
+       }
+       foreach ($this->aWorld['after'] as $aAfterHook) {
+         if (array_key_exists('tags', $aAfterHook)) {
+           if (count($aAfterHook['tags']) == 0 || count(array_intersect($aTags, $aAfterHook['tags'])) > 0) {
+             $oStep = CucumberSteps::getInstance($aAfterHook['class'], $this->aGlobals);
+             $oResult = $oStep->invoke($aAfterHook['method']);
+             if ($oResult === false) {
+               return array('failure');
+             }
+           }
+         }
+       }
+       return array('success');
+     }
 
     /**
      * @param  $iStepId
@@ -104,6 +112,25 @@ class CucumberScenario {
     function invoke($iStepId, $aArgs) {
         $aStep = $this->aWorld['steps'][$iStepId];
         $oStep = new $aStep['class']($this->aGlobals);
+        foreach ($aArgs as &$sArg) {
+          $sArgTest = $sArg;
+          if (is_array($sArgTest)) {
+            $sArgTest = "table:" . implode(",",$sArgTest[0]);
+          }
+          foreach (array_reverse($this->aWorld['transform'],true) as $aTransform) {
+            $aMatches = array();
+            if (preg_match_all($aTransform['regexp'], $sArgTest, $aMatches, PREG_OFFSET_CAPTURE)) {
+              $oTransform = new $aTransform['class']($this->aGlobals);
+              if (is_array($sArg)) {
+                $sArg = call_user_func_array(array($oTransform, $aTransform['method']),$sArg);                
+              } else {
+                $sArg = call_user_func_array(array($oTransform, $aTransform['method']),$aMatches[1][0]);                
+              }
+              break;
+            }
+          }
+          
+        }
         try {
             call_user_func_array(array($oStep, $aStep['method']),$aArgs);
         } catch (PHPUnit_Framework_IncompleteTestError $e) {
@@ -113,7 +140,7 @@ class CucumberScenario {
         } catch (PHPUnit_Framework_ExpectationFailedException $e) {
             return array('fail', array('message' => $e->getMessage()));
         } catch (Exception $e) {
-            return array('fail', array('exception' => $e->__toString()));            
+            return array('fail', array('message' => $e->getMessage() . " " . $e->getFile() . ":" . $e->getLine(), 'exception' => get_class($e), 'backtrace' => $e->getTraceAsString()));
         }
         return array('success');
     }

data/lib/CucumberSteps.php

@@ -74,6 +74,26 @@ class CucumberSteps extends PHPUnit_Framework_Assert {
             return new $sClass($aGlobals);
         }
     }
+    
+    public function __set($sName, $sValue) {
+      $this->aGlobals[$sName] = $sValue;
+    }
+    
+    public function __get($sName) {
+      if (array_key_exists($sName, $this->aGlobals)) {
+        return $this->aGlobals[$sName];        
+      } else {
+        trigger_error("Property ($sName) not defined", E_USER_ERROR);
+      }
+    }
+    
+    public function __unset($sName) {
+      unset($this->aGlobals[$sName]);
+    }
+    
+    public function __isset($sName) {
+      return isset($this->aGlobals[$sName]);
+    }
 }
 
 ?>

data/lib/Cuke4Php.php

@@ -21,7 +21,8 @@ class Cuke4Php {
     public $aWorld = array(
         'steps' => array(),
         'before' => array(),
-        'after' => array()
+        'after' => array(),
+        'transform' => array()
     );
 
     function __construct($_sFeaturePath, $_iPort = 16816) {
@@ -33,10 +34,15 @@ class Cuke4Php {
         } else {
             $this->iPort = 16816;
         }
-
+                
         foreach (self::rglob("*.php", 0,  $_sFeaturePath . "/support") as $sFilename) {
             require_once $sFilename;
         }
+        set_error_handler(
+          array('PHPUnit_Util_ErrorHandler', 'handleError'),
+          E_ALL | E_STRICT
+        );
+        
         require_once "Cucumber.php";
         foreach (self::rglob("*.php", 0,  $_sFeaturePath . "/step_definitions") as $sFilename) {
             require_once $sFilename;
@@ -71,6 +77,12 @@ class Cuke4Php {
                     $this->aWorld['after'][] = $aMethod;
                     continue;
                 }
+                if (substr($oMethod->name, 0, 9) == "transform") {
+                    preg_match("/(?:Transform) (.+)$/im", $sComment, $aMatches);
+                    $aMethod['regexp'] = $aMatches[1];
+                    $this->aWorld['transform'][] = $aMethod;
+                    continue;
+                }
             }
         }
     }
@@ -114,9 +126,9 @@ class Cuke4Php {
                 $data = trim($input);
                 if ($data !== "") {
                     $output = json_encode($this->process($data)) . "\n";
-										if ($this->bRun) {
-	                    socket_write($connection, $output);											
-										}
+                    if ($this->bRun) {
+                      socket_write($connection, $output);
+                    }
                 }
             }
             socket_close($connection);
@@ -134,7 +146,8 @@ class Cuke4Php {
             default:
                 $aCommand = json_decode($sInput);
                 $sAction = $aCommand[0];
-                $sData = NULL;
+                $sData = new stdClass;
+                $sData->tags = array();
                 if (array_key_exists(1, $aCommand)) {
                     $sData = $aCommand[1];
                 }

data/tests/lib/CucumberScenarioTest.php

@@ -35,6 +35,7 @@ class CucumberScenarioTest extends PHPUnit_Framework_TestCase {
     public function setup() {
         CucumberSteps::clearMocks();
         $this->aWorld = array(
+            'transform' => array(),
             'before' => array(
                 array(
                     'tags' => array('one'),
@@ -149,7 +150,10 @@ class CucumberScenarioTest extends PHPUnit_Framework_TestCase {
     }
 
     public function testInvokeShouldFailWhenExceptionThrown() {
-        self::assertEquals(array('fail',array('exception' => 'TestException')), $this->oScenario->invoke(5,array()));
+      $aResult = $this->oScenario->invoke(5,array());
+      self::assertEquals('fail',$aResult[0]);
+      self::assertEquals('Exception', $aResult[1]['exception']);
+      self::assertEquals('test exception /Users/kolbrich/local_src/cuke4php/features/step_definitions/TestSteps.php:48', $aResult[1]['message']);
     }
 
     public function testInvokeShouldSucceedWithParameters() {

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: cuke4php
 version: !ruby/object:Gem::Version 
-  hash: 63
+  hash: 61
   prerelease: false
   segments: 
   - 0
   - 9
-  - 2
-  version: 0.9.2
+  - 3
+  version: 0.9.3
 platform: ruby
 authors: 
 - Kevin Olbrich
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-01-27 00:00:00 -05:00
+date: 2011-03-23 00:00:00 -04:00
 default_executable: cuke4php
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -85,10 +85,12 @@ files:
 - cucumber.yml
 - cuke4php.gemspec
 - features/Cuke4Php.feature
+- features/scenario.feature
 - features/step_definitions/Cuke4Php.wire
 - features/step_definitions/TestSteps.php
 - features/step_definitions/WireSteps.php
 - features/support/Env.php
+- features/transform.feature
 - lib/Cucumber.php
 - lib/CucumberScenario.php
 - lib/CucumberSteps.php