cucumber-tcl 0.0.4 → 0.0.5

data/CONTRIBUTING.md

@@ -16,14 +16,14 @@ Now release it
     git commit -m "Release `cat lib/cucumber/tcl/version`"
     rake release
 
-## Gaining Release Karma
+## Gaining Release Privileges
 
-To become a release manager, create a pull request adding your name to the list below, and include your [Rubygems email address](https://rubygems.org/sign_up) in the ticket. One of the existing Release managers will then add you.
+To become a release manager, create a pull request adding your name to the list below, and make sure to include a link to your [Rubygems profile](https://rubygems.org/sign_up). One of the existing release managers will then add you.
 
 Current release managers:
   * [Matt Wynne](https://rubygems.org/profiles/mattwynne)
   * [Jonathan Owers](https://rubygems.org/profiles/jowers)
 
-To grant release karma, issue the following command:
+To grant release privilege, issue the following command:
 
     gem owner cucumber-tcl --add <NEW OWNER RUBYGEMS EMAIL>

data/features/data_tables.feature

@@ -1,6 +1,5 @@
 Feature: DataTables
 
-  @wip
   Scenario: Match a step with a DataTable
     Given a file named "features/test.feature" with:
       """

data/features/define_a_step.feature

@@ -46,3 +46,110 @@ Feature: Define a step
       Hello 123
       """
 
+  Scenario: Define a feature with no steps file
+    Given a file named "features/test.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given undefined
+      """
+    And a file named "features/support/env.rb" with:
+      """
+      require 'cucumber/tcl'
+      """
+    When I run `cucumber`
+    Then it should pass with:
+      """
+      Feature: 
+
+        Scenario:         # features/test.feature:2
+          Given undefined # features/test.feature:3
+
+      1 scenario (1 undefined)
+      1 step (1 undefined)
+      """
+
+  Scenario: Define a failing step
+    Given a file named "features/test.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given failing
+      """
+    And a file named "features/support/env.rb" with:
+      """
+      require 'cucumber/tcl'
+      """
+    And a file named "features/step_defintions/steps.tcl" with:
+      """
+      Given {^failing$} {
+        error "Failing Step"
+      }
+      """
+    When I run `cucumber`
+    Then it should fail with:
+      """
+      Feature: 
+      
+        Scenario:       # features/test.feature:2
+          Given failing # features/test.feature:3
+            Failing Step
+                while executing
+            "error "Failing Step""
+                ("eval" body line 2)
+                invoked from within
+            "eval $existing_step_body" (Tcl::Error)
+            features/test.feature:3:in `Given failing'
+      
+      Failing Scenarios:
+      cucumber features/test.feature:2 # Scenario: 
+      
+      1 scenario (1 failed)
+      1 step (1 failed)
+      """
+
+  Scenario: Define a step that calls a failing proc
+    Given a file named "features/test.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given failing
+      """
+    And a file named "features/support/env.rb" with:
+      """
+      require 'cucumber/tcl'
+      """
+    And a file named "features/step_defintions/steps.tcl" with:
+      """
+      Given {^failing$} {
+        failing_proc
+      }
+      proc failing_proc {} {
+        error "Failing Step"
+      }
+      """
+    When I run `cucumber`
+    Then it should fail with:
+      """
+      Feature: 
+      
+        Scenario:       # features/test.feature:2
+          Given failing # features/test.feature:3
+            Failing Step
+                while executing
+            "error "Failing Step""
+                (procedure "failing_proc" line 2)
+                invoked from within
+            "failing_proc"
+                ("eval" body line 2)
+                invoked from within
+            "eval $existing_step_body" (Tcl::Error)
+            features/test.feature:3:in `Given failing'
+      
+      Failing Scenarios:
+      cucumber features/test.feature:2 # Scenario: 
+      
+      1 scenario (1 failed)
+      1 step (1 failed)
+      """
+

data/features/pending_step.feature

@@ -0,0 +1,41 @@
+Feature: A step that is still pending implementation
+
+  Calling `pending` from a Tcl step definition will fail that scenario as
+  pending.
+
+  Still to do:
+
+  - [pass a message back about why the step is pending](https://github.com/cucumber/cucumber-ruby-tcl/issues/24)
+  - [display the file:line where `pending` was called in backtrace](https://github.com/cucumber/cucumber-ruby-tcl/issues/25)
+
+  Scenario: A un-implemented step returns pending
+    Given a file named "features/test.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given pending
+      """
+    And a file named "features/support/env.rb" with:
+      """
+      require 'cucumber/tcl'
+      """
+    And a file named "features/step_defintions/steps.tcl" with:
+      """
+      Given {^pending$} {
+        pending
+      }
+      """
+    When I run `cucumber -q`
+    Then it should pass with:
+      """
+      Feature: 
+
+        Scenario: 
+          Given pending
+            TODO: Step not yet implemented (Cucumber::Core::Test::Result::Pending)
+            features/test.feature:3:in `Given pending'
+
+      1 scenario (1 pending)
+      1 step (1 pending)
+      """
+

data/lib/cucumber/tcl.rb

@@ -1,11 +1,23 @@
 require 'cucumber/tcl/activate_steps'
+require 'cucumber/tcl/framework'
 require 'cucumber/tcl/step_definitions'
 
+# Use Cucumber's configuration hook to install the plugin
 if respond_to?(:AfterConfiguration)
   AfterConfiguration do |config|
-    create_step_definitions = lambda {
-      Cucumber::Tcl::StepDefinitions.new(File.dirname(__FILE__) + '/tcl/framework.tcl')
-    }
-    config.filters << Cucumber::Tcl::ActivateSteps.new(create_step_definitions)
+    Cucumber::Tcl.install config
+  end
+end
+
+module Cucumber
+  module Tcl
+
+    def self.install(cucumber_config)
+      create_step_definitions = lambda {
+        StepDefinitions.new(Framework.new)
+      }
+      cucumber_config.filters << ActivateSteps.new(create_step_definitions)
+    end
+
   end
 end

data/lib/cucumber/tcl/framework.rb

@@ -0,0 +1,19 @@
+module Cucumber
+  module Tcl
+    class Framework
+      TCL_FRAMEWORK_PATH = File.dirname(__FILE__) + '/framework.tcl'
+
+      def initialize(path = TCL_FRAMEWORK_PATH)
+        @tcl = ::Tcl::Interp.load_from_file(path)
+      end
+
+      def step_definition_exists?(step_name)
+        @tcl.proc('step_definition_exists').call(step_name) == "1"
+      end
+
+      def execute_step_definition(*args)
+        @tcl.proc('execute_step_definition').call(*args)
+      end
+    end
+  end
+end

data/lib/cucumber/tcl/framework.tcl

@@ -1,36 +1,42 @@
 
-# Set a variable to allow this to be more easily tested
-if {[info exists env(TEST)] && $env(TEST) eq 1} {
-  set TEST 1
-} else {
-  set TEST 0
-}
+namespace eval ::cucumber:: {
+  variable STEPS [list]
+  variable TEST
+
+  # Set a variable to allow this to be more easily tested
+  if {[info exists env(TEST)] && $::env(TEST) eq 1} {
+    set TEST 1
+  } else {
+    set TEST 0
+  }
 
-#TODO make this a namespace to avoid globals
-set STEPS [list]
+  namespace export step_definition_exists
+  namespace export execute_step_definition
+  namespace export Given
+  namespace export When
+  namespace export Then
+  namespace export pending
+
+}
 
 #
 # Define procs to match Gherkin keyworkds that put data in the STEPS array
 #
-proc Given args {
-  _add_step {*}$args
-}
-
-proc When args {
+proc ::cucumber::Given args {
   _add_step {*}$args
 }
 
-proc Then args {
+proc ::cucumber::When args {
   _add_step {*}$args
 }
 
-proc And args {
+proc ::cucumber::Then args {
   _add_step {*}$args
 }
 
-proc _add_step args {
+proc ::cucumber::_add_step args {
 
-  global STEPS
+  variable STEPS
 
   if {[llength $args] == 2} {
     set re [lindex $args 0]
@@ -50,21 +56,21 @@ proc _add_step args {
 
 #
 # Procs needed by cucumber for checking and executing steps
-proc step_definition_exists { step_name } {
+proc ::cucumber::step_definition_exists { step_name } {
   set res [_search_steps $step_name 0]
   return $res
 }
 
 
-proc execute_step_definition { step_name {multiline_args {}} } {
+proc ::cucumber::execute_step_definition { step_name {multiline_args {}} } {
   set res [_search_steps $step_name 1 $multiline_args]
   return $res
 
 }
 
 
-proc _search_steps {step_name {execute 0} {multiline_args {}}} {
-  global STEPS
+proc ::cucumber::_search_steps {step_name {execute 0} {multiline_args {}}} {
+  variable STEPS
 
   foreach step $STEPS {
     set existing_step_name   [lindex $step 0]
@@ -81,7 +87,14 @@ proc _search_steps {step_name {execute 0} {multiline_args {}}} {
       }
       
       if {$execute == 1} {
-        eval $existing_step_body
+        if {[catch {
+          eval $existing_step_body
+        } msg]} {
+          if {$msg eq "pending"} {
+            return "pending"
+          }
+          error $::errorInfo
+        }
       }
       return 1
     }
@@ -89,9 +102,20 @@ proc _search_steps {step_name {execute 0} {multiline_args {}}} {
   return 0
 }
 
-if {$TEST ne 1} {
-  #TODO let that path be configurable from cucumber-ruby
-  foreach x [glob features/**/*.tcl] {
-      source $x
+proc ::cucumber::source_steps args {
+  variable TEST
+
+  if {$TEST ne 1} {
+    #TODO let that path be configurable from cucumber-ruby
+    foreach x [glob -nocomplain features/**/*.tcl] {
+        source $x
+    }
   }
 }
+
+proc ::cucumber::pending args {
+  error "pending"
+}
+
+namespace import ::cucumber::*
+::cucumber::source_steps

data/lib/cucumber/tcl/step_definitions.rb

@@ -5,9 +5,8 @@ module Cucumber
   module Tcl
 
     class StepDefinitions
-      def initialize(path)
-        raise ArgumentError, "cucumber-tcl entry point #{path} does not exist." unless File.exists?(path)
-        @tcl = ::Tcl::Interp.load_from_file(path)
+      def initialize(tcl_framework)
+        @tcl_framework = tcl_framework
       end
 
       def attempt_to_activate(test_step)
@@ -18,20 +17,33 @@ module Cucumber
       private
 
       def match?(test_step)
-        step_name = test_step.name
-        @tcl.proc('step_definition_exists').call(step_name) == "1"
+        @tcl_framework.step_definition_exists?(test_step.name)
       end
 
       def action_for(test_step)
-        step_name = test_step.name
-        arguments = ArgumentList.new(step_name)
-        test_step.source.last.multiline_arg.describe_to(arguments)
-        proc { @tcl.proc('execute_step_definition').call(*arguments) }
+        arguments = ArgumentList.new(test_step)
+        proc { 
+          response = ExecuteResponse.new(@tcl_framework.execute_step_definition(*arguments))
+          response.raise_any_pending_error
+        }
+      end
+
+      class ExecuteResponse
+        def initialize(raw)
+          @raw = raw
+        end
+
+        def raise_any_pending_error
+          if @raw == "pending"
+            raise Cucumber::Core::Test::Result::Pending.new("TODO: Step not yet implemented")
+          end
+        end
       end
 
       class ArgumentList
-        def initialize(*args)
-          @arguments = args
+        def initialize(test_step)
+          @arguments = [test_step.name]
+          test_step.source.last.multiline_arg.describe_to self
         end
 
         def doc_string(arg)

data/lib/cucumber/tcl/test/test_framework.tcl

@@ -2,40 +2,41 @@ package require tcltest 2
 namespace import tcltest::*
 
 source "./lib/cucumber/tcl/framework.tcl"
+namespace import cucumber::*
 
 #
 # Test Given
 #
 test Given-1 {calling Given with 2 parameters adds a new entry to the STEPS list with an empty parameters list} {
   -setup {
-    set ::STEPS [list]
+    set ::cucumber::STEPS [list]
   }
   -body {
     Given {^Regular Expression$} { puts "Given RegExp" }
-    expr { [llength $::STEPS] == 1 && [llength [lindex $::STEPS 0]] == 3}
+    expr { [llength $::cucumber::STEPS] == 1 && [llength [lindex $::cucumber::STEPS 0]] == 3}
   }
   -result 1
 }
 
 test Given-2 {calling Given twice adds 2 entries to the STEPS list} {
   -setup {
-    set ::STEPS [list]
+    set ::cucumber::STEPS [list]
   }
   -body {
     Given {^Regular Expression$} { puts "Given RegExp" }
     Given {^Regular Expression 2$} { puts "Given RegExp 2" }
-    expr { [llength $::STEPS] == 2 && [llength [lindex $::STEPS 0]] == 3}
+    expr { [llength $::cucumber::STEPS] == 2 && [llength [lindex $::cucumber::STEPS 0]] == 3}
   }
   -result 1
 }
 
 test Given-3 {calling Given with 3 parameters adds a new entry to the STEPS list} {
   -setup {
-    set ::STEPS [list]
+    set ::cucumber::STEPS [list]
   }
   -body {
     Given {^Regular Expression (\d+)$} {match} { puts "Given RegExp $match" }
-    expr { [llength $::STEPS] == 1 && [llength [lindex $::STEPS 0]] == 3}
+    expr { [llength $::cucumber::STEPS] == 1 && [llength [lindex $::cucumber::STEPS 0]] == 3}
   }
   -result 1
 }
@@ -45,41 +46,41 @@ test Given-3 {calling Given with 3 parameters adds a new entry to the STEPS list
 #
 test _add_step-1 {calling _add_step with 2 parameters adds a new entry to the STEPS list with an empty parameters list} {
   -setup {
-    set ::STEPS [list]
+    set ::cucumber::STEPS [list]
   }
   -body {
-    _add_step {^Regular Expression$} { puts "Given RegExp" }
-    expr { [llength $::STEPS] == 1 && [llength [lindex $::STEPS 0]] == 3}
+    ::cucumber::_add_step {^Regular Expression$} { puts "Given RegExp" }
+    expr { [llength $::cucumber::STEPS] == 1 && [llength [lindex $::cucumber::STEPS 0]] == 3}
   }
   -result 1
 }
 
 test _add_step-2 {calling _add_step twice adds 2 entries to the STEPS list} {
   -setup {
-    set ::STEPS [list]
+    set ::cucumber::STEPS [list]
   }
   -body {
-    _add_step {^Regular Expression$} { puts "Given RegExp" }
-    _add_step {^Regular Expression 2$} { puts "Given RegExp 2" }
-    expr { [llength $::STEPS] == 2 && [llength [lindex $::STEPS 0]] == 3}
+    ::cucumber::_add_step {^Regular Expression$} { puts "Given RegExp" }
+    ::cucumber::_add_step {^Regular Expression 2$} { puts "Given RegExp 2" }
+    expr { [llength $::cucumber::STEPS] == 2 && [llength [lindex $::cucumber::STEPS 0]] == 3}
   }
   -result 1
 }
 
 test _add_step-3 {calling _add_step with 3 parameters adds a new entry to the STEPS list} {
   -setup {
-    set ::STEPS [list]
+    set ::cucumber::STEPS [list]
   }
   -body {
-    _add_step {^Regular Expression (\d+)$} {match} { puts "Given RegExp $match" }
-    expr { [llength $::STEPS] == 1 && [llength [lindex $::STEPS 0]] == 3}
+    ::cucumber::_add_step {^Regular Expression (\d+)$} {match} { puts "Given RegExp $match" }
+    expr { [llength $::cucumber::STEPS] == 1 && [llength [lindex $::cucumber::STEPS 0]] == 3}
   }
   -result 1
 }
 
 test _add_step-4 {calling _add_step with more than 3 parameters adds a new entry to the STEPS list} {
   -body {
-    _add_step {^Match1 (\w+) Match2 (\d+) Match3 (\d+)$} {match1} {match2} {match3} { puts "Given RegExp $match" }
+    ::cucumber::_add_step {^Match1 (\w+) Match2 (\d+) Match3 (\d+)$} {match1} {match2} {match3} { puts "Given RegExp $match" }
   }
   -returnCodes error
   -result {The parameters for this procedure are regular_expression ?list_of_capture_variables? body}
@@ -92,12 +93,12 @@ test _add_step-4 {calling _add_step with more than 3 parameters adds a new entry
 #
 test When-1 {calling When adds a new entry to the STEPS list} {
   -setup {
-    set ::STEPS [list]
+    set ::cucumber::STEPS [list]
   }
   -body {
     When {^Regular Expression$} { puts "When RegExp" }
-    expr { [llength $::STEPS] == 1 }
-    expr { [llength $::STEPS] == 1 && [llength [lindex $::STEPS 0]] == 3}
+    expr { [llength $::cucumber::STEPS] == 1 }
+    expr { [llength $::cucumber::STEPS] == 1 && [llength [lindex $::cucumber::STEPS 0]] == 3}
   }
   -result 1
 }
@@ -109,27 +110,11 @@ test When-1 {calling When adds a new entry to the STEPS list} {
 #
 test Then-1 {calling Then adds a new entry to the STEPS list} {
   -setup {
-    set ::STEPS [list]
+    set ::cucumber::STEPS [list]
   }
   -body {
     Then {^Regular Expression$} { puts "Then RegExp" }
-    expr { [llength $::STEPS] == 1 && [llength [lindex $::STEPS 0]] == 3}
-  }
-  -result 1
-}
-
-
-
-#
-# Test And
-#
-test And-1 {calling And adds a new entry to the STEPS list} {
-  -setup {
-    set ::STEPS [list]
-  }
-  -body {
-    And {^Regular Expression$} { puts "And RegExp" }
-    expr { [llength $::STEPS] == 1 && [llength [lindex $::STEPS 0]] == 3}
+    expr { [llength $::cucumber::STEPS] == 1 && [llength [lindex $::cucumber::STEPS 0]] == 3}
   }
   -result 1
 }
@@ -141,56 +126,56 @@ test And-1 {calling And adds a new entry to the STEPS list} {
 #
 test _search_steps-1 {_search_steps returns 0 if there are no existing steps} {
   -setup {
-    set ::STEPS [list]
+    set ::cucumber::STEPS [list]
   }
   -body {
-    _search_steps {Unknown Regexp}
+    ::cucumber::_search_steps {Unknown Regexp}
   }
   -result 0
 }
 
 test _search_steps-2 {_search_steps returns 0 if there are no matching steps} {
   -setup {
-    set ::STEPS [list [list {^First Step$} {} {puts "First Step"}]]
+    set ::cucumber::STEPS [list [list {^First Step$} {} {puts "First Step"}]]
   }
   -body {
-    _search_steps {Unknown Regexp}
+    ::cucumber::_search_steps {Unknown Regexp}
   }
   -result 0
 }
 
 test _search_steps-3 {_search_steps returns 1 if there is a matching step} {
   -setup {
-    set ::STEPS [list [list {^First Step$} {} {puts "First Step"}]]
+    set ::cucumber::STEPS [list [list {^First Step$} {} {puts "First Step"}]]
   }
   -body {
-    _search_steps {First Step}
+    ::cucumber::_search_steps {First Step}
   }
   -result 1
 }
 
 test _search_steps-4 {_search_steps returns 1 if there is a matching step with multiple values in STEPS} {
   -setup {
-    set ::STEPS [list \
+    set ::cucumber::STEPS [list \
       [list {^First Step$} {} {puts "First Step"}] \
       [list {^Second Step$} {} {puts "Second Step"}] \
     ]
   }
   -body {
-    _search_steps {Second Step}
+    ::cucumber::_search_steps {Second Step}
   }
   -result 1
 }
 
 test _search_steps-5 {_search_steps returns 1 and executes body of step if there is a matching step and execute is set to 1} {
   -setup {
-    set ::STEPS [list \
+    set ::cucumber::STEPS [list \
       [list {^First Step$} {} {puts "First Step"}] \
       [list {^Second Step$} {} {puts "Second Step"}] \
     ]
   }
   -body {
-    _search_steps {Second Step} {1}
+    ::cucumber::_search_steps {Second Step} {1}
   }
   -result 1
   -match glob
@@ -199,13 +184,13 @@ test _search_steps-5 {_search_steps returns 1 and executes body of step if there
 
 test _search_steps-6 {_search_steps returns 1 and executes body of step if there is a matching step and execute is set to 1 with a parameter in the match} {
   -setup {
-    set ::STEPS [list \
+    set ::cucumber::STEPS [list \
       [list {^First Step$} {} {puts "First Step"}] \
       [list {^Second (\w+)$} {match} {puts "Second $match"}] \
     ]
   }
   -body {
-    _search_steps {Second Step} {1}
+    ::cucumber::_search_steps {Second Step} {1}
   }
   -result 1
   -match glob
@@ -214,13 +199,13 @@ test _search_steps-6 {_search_steps returns 1 and executes body of step if there
 
 test _search_steps-7 {_search_steps returns 1 and executes body of step if there is a matching step and execute is set to 1 with 2 parameters in the match} {
   -setup {
-    set ::STEPS [list \
+    set ::cucumber::STEPS [list \
       [list {^First Step$} {} {puts "First Step"}] \
       [list {^(\w+) (\w+)$} {match1 match2} {puts "$match1 $match2"}] \
     ]
   }
   -body {
-    _search_steps {Second Step} {1}
+    ::cucumber::_search_steps {Second Step} {1}
   }
   -result 1
   -match glob
@@ -230,13 +215,13 @@ test _search_steps-7 {_search_steps returns 1 and executes body of step if there
 # Testing multiline args
 test _search_steps-8 {_search_steps returns 1 and executes body of step if there is a matching step, execute is set to 1 and there is a multiline_arg passed in} {
   -setup {
-    set ::STEPS [list \
+    set ::cucumber::STEPS [list \
       [list {^First Step$} {} {puts "First Step"}] \
       [list {^Second Step:$} {content} {puts "$content"}] \
     ]
   }
   -body {
-    _search_steps {Second Step:} {1} {Multiline Content}
+    ::cucumber::_search_steps {Second Step:} {1} {Multiline Content}
   }
   -result 1
   -match glob
@@ -245,19 +230,41 @@ test _search_steps-8 {_search_steps returns 1 and executes body of step if there
 
 test _search_steps-9 {_search_steps returns 1 and executes body of step if there is a matching step, execute is set to 1 and there is a multiline_arg passed in and there is a parameter match in the regexp} {
   -setup {
-    set ::STEPS [list \
+    set ::cucumber::STEPS [list \
       [list {^First Step$} {} {puts "First Step"}] \
       [list {^Second (\w+):$} {match1 content} {puts "content=$content, match=$match1"}] \
     ]
   }
   -body {
-    _search_steps {Second Step:} {1} {Multiline Content}
+    ::cucumber::_search_steps {Second Step:} {1} {Multiline Content}
   }
   -result 1
   -match glob
   -output {content=Multiline Content, match=Step*}
 }
 
+test _search_steps-10 {_search_steps returns "pending" if there is a matching step, execute is set to 1 and the proc to be executed is pending} {
+  -setup {
+    set ::cucumber::STEPS [list \
+      [list {^Pending$} {} {pending}] \
+    ]
+  }
+  -body {
+    ::cucumber::_search_steps {Pending} {1} {}
+  }
+  -result "pending"
+}
+
+#
+# Test Pending
+#
+test pending-1 {pending returns an error with the text "pending"} {
+  -setup {}
+  -body {pending}
+  -returnCodes error
+  -result {pending}
+}
+
 #
 # Cleanup
 #

data/lib/cucumber/tcl/version

@@ -1 +1 @@
-0.0.4
+0.0.5

data/spec/cucumber/tcl/step_definitions_spec.rb

@@ -4,13 +4,27 @@ require 'cucumber/core/test/step'
 
 module Cucumber::Tcl
   describe StepDefinitions do
+    let(:location) { double }
+    let(:test_step) {
+      ast_step = double(name: double, location: location, multiline_arg: Cucumber::Core::Ast::EmptyMultilineArgument.new)
+      Cucumber::Core::Test::Step.new([ ast_step ])
+    }
 
     it "can activate a passing tcl step" do
-      step_definitions = StepDefinitions.new(File.dirname(__FILE__) + '/fixtures/everything_ok.tcl')
-      location = double
-      ast_step = double(name: double, location: location, multiline_arg: Cucumber::Core::Ast::EmptyMultilineArgument.new)
-      test_step = Cucumber::Core::Test::Step.new([ ast_step ])
+      path = File.dirname(__FILE__) + '/fixtures/everything_ok.tcl'
+      tcl_framework = Framework.new(path)
+      step_definitions = StepDefinitions.new(tcl_framework)
       expect(step_definitions.attempt_to_activate(test_step).location).to eq location
     end
+
+    it "raises a pending error when TCL returns a pending message" do
+      tcl_framework = double(
+        step_definition_exists?: true,
+        execute_step_definition: "pending"
+      )
+      step_definitions = StepDefinitions.new(tcl_framework)
+      result = step_definitions.attempt_to_activate(test_step).execute
+      expect(result).to be_a Cucumber::Core::Test::Result::Pending
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cucumber-tcl
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-02 00:00:00.000000000 Z
+date: 2015-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-tcl
@@ -125,11 +125,13 @@ files:
 - features/data_tables.feature
 - features/define_a_step.feature
 - features/doc_strings.feature
+- features/pending_step.feature
 - features/reset_state.feature
 - features/support/aruba.rb
 - lib/cucumber/tcl.rb
 - lib/cucumber/tcl/activate_steps.rb
 - lib/cucumber/tcl/data_table.rb
+- lib/cucumber/tcl/framework.rb
 - lib/cucumber/tcl/framework.tcl
 - lib/cucumber/tcl/step_definitions.rb
 - lib/cucumber/tcl/test/test_framework.tcl
@@ -162,6 +164,6 @@ rubyforge_project:
 rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
-summary: cucumber-tcl-0.0.4
+summary: cucumber-tcl-0.0.5
 test_files: []
 has_rdoc: