yet-another-cucumber-tcl 0.0.9

data/features/reset_state.feature

@@ -0,0 +1,61 @@
+Feature: Reset state
+
+  In order to keep state from leaking between scenarios, by default,
+  we create a new Tcl interpreter for each test case.
+
+  In order to prevent long setup time before each scenario
+  we can optionally avoid starting a new TCL interpreter
+
+  Rules:
+    -- The state is maintained between scenarios if an environment variable is passed into Cucumber
+    -- Otherwise a new TCL interpreter is started and state is reset on each scenario
+
+  Background:
+    Given a file named "features/test.feature" with:
+      """
+      Feature:
+        Scenario:
+          Given I set a global variable
+          When I print the global variable
+
+        Scenario:
+          When I print the global variable
+      """
+    And a file named "features/step_definitions/steps.tcl" with:
+      """
+      global g
+       
+      Given {^I set a global variable$} {
+        set ::g value
+      }
+
+      When {^I print the global variable$} {
+        puts $::g
+      }
+      """
+    And a file named "features/support/env.rb" with:
+      """
+      require 'cucumber/tcl'
+      """
+	
+  Scenario: State reset when running 'cucumber' with no options
+    When I run `cucumber`
+    Then it should fail with:
+       """
+       can't read "::g": no such variable
+       """
+
+  Scenario: State reset when running 'cucumber' with a new framework object for each scenario
+    When I run `cucumber SHARE_FRAMEWORK=0`
+    Then it should fail with:
+       """
+       can't read "::g": no such variable
+       """
+
+  Scenario: State not reset when running 'cucumber' and sharing framework object
+    When I run `cucumber SHARE_FRAMEWORK=1`
+    Then it should pass with:
+      """
+      2 scenarios (2 passed)
+      3 steps (3 passed)
+      """

data/features/support/aruba.rb

@@ -0,0 +1 @@
+require 'aruba/cucumber'

data/lib/cucumber/tcl/activate_steps.rb

@@ -0,0 +1,25 @@
+require 'cucumber/core/filter'
+
+module Cucumber
+  module Tcl
+    ActivateSteps = Cucumber::Core::Filter.new(:create_step_definitions) do
+      def test_case(test_case)
+        activated_steps = test_case.test_steps.map do |test_step|
+          step_definitions.attempt_to_activate(test_step)
+        end
+        test_case.with_steps(activated_steps).describe_to receiver
+        reset_step_definitons
+      end
+
+      private
+
+      def reset_step_definitons
+        @step_definitions = nil
+      end
+
+      def step_definitions
+        @step_definitions ||= create_step_definitions.call
+      end
+    end
+  end
+end

data/lib/cucumber/tcl/data_table.rb

@@ -0,0 +1,21 @@
+module Cucumber
+  module Tcl
+    # Wraps the Cucumber DataTable so that when passed through to tcl, its
+    # string representation is easy to parse into a tcl list.
+    class DataTable
+      def initialize(original)
+        @raw = original.raw
+      end
+
+      def to_s
+        to_tcl_list(@raw.map { |row| to_tcl_list(row) })
+      end
+
+      private
+
+      def to_tcl_list(array)
+        array.map { |element| "{#{element}}" }.join(' ')
+      end
+    end
+  end
+end

data/lib/cucumber/tcl/framework.rb

@@ -0,0 +1,23 @@
+module Cucumber
+  module Tcl
+    class Framework
+      TCL_FRAMEWORK_PATH = "#{File.dirname(__FILE__)}/framework.tcl".freeze
+
+      def initialize(cucumber_config = nil, path = TCL_FRAMEWORK_PATH)
+        @tcl = ::Tcl::Interp.load_from_file(path)
+
+        all_files_to_load = cucumber_config.nil? ? [] : cucumber_config.all_files_to_load
+        all_files_to_load.collect! { |f| f.gsub(/([\\\s{}])/, '\\\\\1') }
+        @tcl.proc('source_files').call(all_files_to_load.join(' '))
+      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

@@ -0,0 +1,157 @@
+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
+  }
+
+  namespace export source_files
+  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 ::cucumber::Given args {
+  _add_step {*}$args
+}
+
+proc ::cucumber::When args {
+  _add_step {*}$args
+}
+
+proc ::cucumber::Then args {
+  _add_step {*}$args
+}
+
+proc ::cucumber::_add_step args {
+
+  variable STEPS
+
+  if {[llength $args] == 2} {
+    set re [lindex $args 0]
+    set params {}
+    set body [lindex $args 1]
+  } elseif {[llength $args] == 3} {
+    set re [lindex $args 0]
+    set params [lindex $args 1]
+    set body [lindex $args 2]
+  } else {
+    error "The parameters for this procedure are regular_expression ?list_of_capture_variables? body"
+    return 0
+  }
+
+  lappend STEPS [list $re $params $body]
+}
+
+#
+# Procs needed by cucumber for checking and executing steps
+proc ::cucumber::step_definition_exists { step_name } {
+  set res [_search_steps $step_name 0]
+  return $res
+}
+
+
+proc ::cucumber::execute_step_definition { step_name {multiline_args {}} } {
+  set res [_search_steps $step_name 1 $multiline_args]
+  return $res
+
+}
+
+
+proc ::cucumber::_search_steps {step_name {execute 0} {multiline_args {}}} {
+  variable STEPS
+
+  foreach step $STEPS {
+    set existing_step_name   [lindex $step 0]
+    set existing_step_params [lindex $step 1]
+    set existing_step_body   [lindex $step 2]
+
+    if {[regexp $existing_step_name $step_name matchresult {*}[join $existing_step_params]]} {
+
+      # Now we've found a match, handle multiline args. The name of the var
+      # should be the last value of the $existing_step_params.
+      if {$multiline_args ne {}} {
+        set multiline_var_name [lindex $existing_step_params end]
+        set $multiline_var_name $multiline_args
+      }
+
+      if {$execute == 1} {
+        set retCode [catch {
+          eval $existing_step_body
+        } msg]
+        if {$retCode == 1} {
+          # we caught an TCL_ERROR and will check for error message
+          if {$msg eq "skipped"} {
+            return "skipped"
+          } elseif {$msg eq "pending"} {
+            return "pending"
+          } elseif {$msg eq "undefined"} {
+            return "undefined"
+          }
+          error $::errorInfo
+        }
+      }
+      return 1
+    }
+  }
+  return 0
+}
+
+# Sort a list of files such that: */support/env.{ext} < */support/{file} < */{file}
+proc ::cucumber::_sort_by_source_priority {a b} {
+
+  if {[string equal [lindex [file split $a] end-1] "support"]} {
+    if {[string equal [file rootname [lindex [file split $a] end]] "env"]} {
+      set a_order 1
+    } else {
+      set a_order 2
+    }
+  } else {
+    set a_order 3
+  }
+
+  if {[string equal [lindex [file split $b] end-1] "support"]} {
+    if {[string equal [file rootname [lindex [file split $b] end]] "env"]} {
+      set b_order 1
+    } else {
+      set b_order 2
+    }
+  } else {
+    set b_order 3
+  }
+
+  return [expr {$a_order - $b_order}]
+}
+
+proc ::cucumber::source_files {files} {
+  variable TEST
+
+  if {$TEST ne 1} {
+    foreach file [lsort -command _sort_by_source_priority $files] {
+      if {[string equal [file extension $file] ".tcl"]} {
+        if {[catch {
+          uplevel #0 [list source $file]
+        }]} {
+          error $::errorInfo
+        }
+      }
+    }
+  }
+}
+
+proc ::cucumber::pending args {
+  error "pending"
+}
+
+namespace import ::cucumber::*

data/lib/cucumber/tcl/step_definitions.rb

@@ -0,0 +1,67 @@
+require 'tcl'
+require_relative 'data_table'
+
+module Cucumber
+  module Tcl
+    class StepDefinitions
+      def initialize(tcl_framework)
+        @tcl_framework = tcl_framework
+      end
+
+      def attempt_to_activate(test_step)
+        return test_step unless match?(test_step)
+
+        test_step.with_action(&action_for(test_step))
+      end
+
+      private
+
+      def match?(test_step)
+        @tcl_framework.step_definition_exists?(test_step.text)
+      end
+
+      def action_for(test_step)
+        arguments = ArgumentList.new(test_step)
+        proc {
+          response = ExecuteResponse.new(@tcl_framework.execute_step_definition(*arguments.to_a))
+          response.raise_any_pending_error
+        }
+      end
+
+      class ExecuteResponse
+        def initialize(raw)
+          @raw = raw
+        end
+
+        PENDING_ERRORS = {
+          'pending' => -> { raise Cucumber::Pending, 'TODO: Step not yet implemented' },
+          'skipped' => -> { raise Cucumber::Core::Test::Result::Skipped },
+          'undefined' => -> { raise Cucumber::Core::Test::Result::Undefined }
+        }.freeze
+
+        def raise_any_pending_error
+          PENDING_ERRORS[@raw]&.call
+        end
+      end
+
+      class ArgumentList
+        def initialize(test_step)
+          @arguments = [test_step.text]
+          test_step.multiline_arg.describe_to self
+        end
+
+        def doc_string(arg)
+          @arguments << arg.content
+        end
+
+        def data_table(arg)
+          @arguments << DataTable.new(arg)
+        end
+
+        def to_a
+          @arguments
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,322 @@
+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 ::cucumber::STEPS [list]
+  }
+  -body {
+    Given {^Regular Expression$} { puts "Given RegExp" }
+    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 ::cucumber::STEPS [list]
+  }
+  -body {
+    Given {^Regular Expression$} { puts "Given RegExp" }
+    Given {^Regular Expression 2$} { puts "Given RegExp 2" }
+    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 ::cucumber::STEPS [list]
+  }
+  -body {
+    Given {^Regular Expression (\d+)$} {match} { puts "Given RegExp $match" }
+    expr { [llength $::cucumber::STEPS] == 1 && [llength [lindex $::cucumber::STEPS 0]] == 3}
+  }
+  -result 1
+}
+
+#
+# Test _add_step
+#
+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 ::cucumber::STEPS [list]
+  }
+  -body {
+    ::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 ::cucumber::STEPS [list]
+  }
+  -body {
+    ::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 ::cucumber::STEPS [list]
+  }
+  -body {
+    ::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 {
+    ::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}
+}
+
+
+
+#
+# Test When
+#
+test When-1 {calling When adds a new entry to the STEPS list} {
+  -setup {
+    set ::cucumber::STEPS [list]
+  }
+  -body {
+    When {^Regular Expression$} { puts "When RegExp" }
+    expr { [llength $::cucumber::STEPS] == 1 }
+    expr { [llength $::cucumber::STEPS] == 1 && [llength [lindex $::cucumber::STEPS 0]] == 3}
+  }
+  -result 1
+}
+
+
+
+#
+# Test Then
+#
+test Then-1 {calling Then adds a new entry to the STEPS list} {
+  -setup {
+    set ::cucumber::STEPS [list]
+  }
+  -body {
+    Then {^Regular Expression$} { puts "Then RegExp" }
+    expr { [llength $::cucumber::STEPS] == 1 && [llength [lindex $::cucumber::STEPS 0]] == 3}
+  }
+  -result 1
+}
+
+
+
+#
+# Test _sort_by_source_priority procedure
+#
+test _sort_by_source_priority-1 {_sort_by_source_priority prioritises support/env.{ext} over other support/ files} {
+  -body {
+    set sort [::cucumber::_sort_by_source_priority "test/support/abc.ext" "test/support/env.ext"]
+    # only interested if sort is +ve, 0 or -ve; convert to 1, 0 or -1
+    expr { $sort == 0 ? 0 : $sort / abs($sort) }
+  }
+  -result 1
+}
+
+test _sort_by_source_priority-2 {_sort_by_source_priority prioritises support/env.{ext} over other support/ files} {
+  -body {
+    set sort [::cucumber::_sort_by_source_priority "test/support/env.ext" "test/support/abc.ext"]
+    # only interested if sort is +ve, 0 or -ve; convert to 1, 0 or -1
+    expr { $sort == 0 ? 0 : $sort / abs($sort) }
+  }
+  -result -1
+}
+
+test _sort_by_source_priority-3 {_sort_by_source_priority prioritises support/ files over other files} {
+  -body {
+    set sort [::cucumber::_sort_by_source_priority "test/features/abc.ext" "test/support/abc.ext"]
+    # only interested if sort is +ve, 0 or -ve; convert to 1, 0 or -1
+    expr { $sort == 0 ? 0 : $sort / abs($sort) }
+  }
+  -result 1
+}
+
+test _sort_by_source_priority-4 {_sort_by_source_priority prioritises support/ files over other files} {
+  -body {
+    set sort [::cucumber::_sort_by_source_priority "test/support/abc.ext" "test/features/abc.ext"]
+    # only interested if sort is +ve, 0 or -ve; convert to 1, 0 or -1
+    expr { $sort == 0 ? 0 : $sort / abs($sort) }
+  }
+  -result -1
+}
+
+test _sort_by_source_priority-5 {_sort_by_source_priority prioritises non support/ files equally} {
+  -body {
+    set sort [::cucumber::_sort_by_source_priority "test/lib/abc.ext" "test/etc/abc.ext"]
+    # only interested if sort is +ve, 0 or -ve; convert to 1, 0 or -1
+    expr { $sort == 0 ? 0 : $sort / abs($sort) }
+  }
+  -result 0
+}
+
+
+
+#
+# Test _search_steps procedure
+#
+test _search_steps-1 {_search_steps returns 0 if there are no existing steps} {
+  -setup {
+    set ::cucumber::STEPS [list]
+  }
+  -body {
+    ::cucumber::_search_steps {Unknown Regexp}
+  }
+  -result 0
+}
+
+test _search_steps-2 {_search_steps returns 0 if there are no matching steps} {
+  -setup {
+    set ::cucumber::STEPS [list [list {^First Step$} {} {puts "First Step"}]]
+  }
+  -body {
+    ::cucumber::_search_steps {Unknown Regexp}
+  }
+  -result 0
+}
+
+test _search_steps-3 {_search_steps returns 1 if there is a matching step} {
+  -setup {
+    set ::cucumber::STEPS [list [list {^First Step$} {} {puts "First Step"}]]
+  }
+  -body {
+    ::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 ::cucumber::STEPS [list \
+      [list {^First Step$} {} {puts "First Step"}] \
+      [list {^Second Step$} {} {puts "Second Step"}] \
+    ]
+  }
+  -body {
+    ::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 ::cucumber::STEPS [list \
+      [list {^First Step$} {} {puts "First Step"}] \
+      [list {^Second Step$} {} {puts "Second Step"}] \
+    ]
+  }
+  -body {
+    ::cucumber::_search_steps {Second Step} {1}
+  }
+  -result 1
+  -match glob
+  -output {Second Step*}
+}
+
+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 ::cucumber::STEPS [list \
+      [list {^First Step$} {} {puts "First Step"}] \
+      [list {^Second (\w+)$} {match} {puts "Second $match"}] \
+    ]
+  }
+  -body {
+    ::cucumber::_search_steps {Second Step} {1}
+  }
+  -result 1
+  -match glob
+  -output {Second Step*}
+}
+
+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 ::cucumber::STEPS [list \
+      [list {^First Step$} {} {puts "First Step"}] \
+      [list {^(\w+) (\w+)$} {match1 match2} {puts "$match1 $match2"}] \
+    ]
+  }
+  -body {
+    ::cucumber::_search_steps {Second Step} {1}
+  }
+  -result 1
+  -match glob
+  -output {Second Step*}
+}
+
+# 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 ::cucumber::STEPS [list \
+      [list {^First Step$} {} {puts "First Step"}] \
+      [list {^Second Step:$} {content} {puts "$content"}] \
+    ]
+  }
+  -body {
+    ::cucumber::_search_steps {Second Step:} {1} {Multiline Content}
+  }
+  -result 1
+  -match glob
+  -output {Multiline Content*}
+}
+
+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 ::cucumber::STEPS [list \
+      [list {^First Step$} {} {puts "First Step"}] \
+      [list {^Second (\w+):$} {match1 content} {puts "content=$content, match=$match1"}] \
+    ]
+  }
+  -body {
+    ::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
+#
+cleanupTests
+

data/lib/cucumber/tcl/version.rb

@@ -0,0 +1,5 @@
+module Cucumber
+  module Tcl
+    VERSION = '0.0.9'.freeze
+  end
+end