aslakhellesoy-cucumber 0.1.99.4 → 0.1.99.5

data/spec/cucumber/parser/feature_parser_spec.rb

@@ -0,0 +1,247 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'cucumber/parser'
+
+module Cucumber
+  module Parser
+    describe Feature do
+      before do
+        @parser = FeatureParser.new
+      end
+
+      def parse(text)
+        feature = @parser.parse_or_fail(text)
+      end
+
+      def parse_file(file)
+        @parser.parse_file(File.dirname(__FILE__) + "/../treetop_parser/" + file)
+      end
+
+      def parse_example_file(file)
+        @parser.parse_file(File.dirname(__FILE__) + "/../../../examples/" + file)
+      end
+
+      describe "Header" do
+        it "should parse Feature with blurb" do
+          parse(%{Feature: hi
+with blurb
+})
+        end
+      end
+
+      describe "Comments" do
+        it "should parse a file with only a one line comment" do
+          parse(%{# My comment
+Feature: hi
+}).to_sexp.should ==
+          [:feature, "Feature: hi\n",
+            [:comment, "# My comment\n"]]
+        end
+
+        it "should parse a file with only a multiline comment" do
+          parse(%{# Hello
+# World
+Feature: hi
+}).to_sexp.should ==
+          [:feature, "Feature: hi\n",
+            [:comment, "# Hello\n# World\n"]]
+        end
+
+        it "should parse a file with no comments" do
+          parse("Feature: hi\n").to_sexp.should ==
+          [:feature, "Feature: hi\n"]
+        end
+
+        it "should parse a file with only a multiline comment with newlines" do
+          parse("# Hello\n\n# World\n").to_sexp.should == 
+          [:feature, "", 
+            [:comment, "# Hello\n\n# World\n"]]
+        end
+      end
+
+      describe "Tags" do
+        it "should parse a file with tags on a feature" do
+          parse("# My comment\n@hello @world Feature: hi\n").to_sexp.should ==
+          [:feature, "Feature: hi\n",
+            [:comment, "# My comment\n"],
+            [:tag, "hello"],
+            [:tag, "world"]]
+        end
+
+        it "should parse a file with tags on a scenario" do
+          parse(%{# FC
+  @ft
+Feature: hi
+
+  @st1 @st2   
+  Scenario: First
+    Given Pepper
+
+@st3 
+   @st4
+  Scenario: Second}).to_sexp.should ==
+          [:feature, "Feature: hi",
+            [:comment, "# FC\n"],
+            [:tag, "ft"],
+            [:scenario, 6, 'Scenario:', 'First',
+              [:tag, "st1"], [:tag, "st2"],
+              [:step, 7, "Given", "Pepper"]],
+            [:scenario, 11, 'Scenario:', 'Second',
+              [:tag, "st3"], [:tag, "st4"]]]
+        end
+      end
+
+      describe "Scenarios" do
+        it "can be empty" do
+          parse("Feature: Hi\n\nScenario: Hello\n").to_sexp.should ==
+          [:feature, "Feature: Hi",
+            [:scenario, 3, "Scenario:", "Hello"]]
+        end
+
+        it "should have steps" do
+          parse("Feature: Hi\nScenario: Hello\nGiven I am a step\n").to_sexp.should ==
+          [:feature, "Feature: Hi",
+            [:scenario, 2, "Scenario:", "Hello",
+              [:step, 3, "Given", "I am a step"]]]
+        end
+
+        it "should have steps with inline table" do
+          parse(%{Feature: Hi
+Scenario: Hello
+Given I have a table
+|a|b|
+}).to_sexp.should ==
+          [:feature, "Feature: Hi",
+            [:scenario, 2, "Scenario:", "Hello",
+              [:step, 3, "Given", "I have a table",
+                [:table,
+                  [:row,
+                    [:cell, "a"],
+                    [:cell, "b"]]]]]]
+        end
+
+        it "should have steps with inline py_string" do
+          parse(%{Feature: Hi
+Scenario: Hello
+Given I have a string
+
+
+   """
+  hello
+  world
+  """
+
+}).to_sexp.should ==
+          [:feature, "Feature: Hi",
+            [:scenario, 2, "Scenario:", "Hello",
+              [:step, 3, "Given", "I have a string",
+                [:py_string, "hello\nworld"]]]]
+        end
+      end
+
+      describe "Scenario Outlines" do
+        it "can be empty" do
+          parse(%{Feature: Hi
+Scenario Outline: Hello
+Given a <what> cucumber
+Examples:
+|what|
+|green|
+}).to_sexp.should ==
+          [:feature, "Feature: Hi",
+            [:scenario_outline, "Scenario Outline:", "Hello",
+              [:step, 3, "Given", "a <what> cucumber"],
+              [:examples, "Examples:", "",
+                [:table, 
+                  [:row, 
+                    [:cell, "what"]], 
+                    [:row, [:cell, "green"]]]]]]
+        end
+
+        it "should have line numbered steps with inline table" do
+          parse(%{Feature: Hi
+Scenario Outline: Hello
+
+Given I have a table
+
+|<a>|<b>|
+Examples:
+|a|b|
+|c|d|
+}).to_sexp.should ==
+          [:feature, "Feature: Hi",
+            [:scenario_outline, "Scenario Outline:", "Hello",
+              [:step, 4, "Given", "I have a table",
+                [:table, 
+                  [:row, 
+                    [:cell, "<a>"], 
+                    [:cell, "<b>"]]]],
+            [:examples, "Examples:", "",
+              [:table,
+                [:row, 
+                  [:cell, "a"], 
+                  [:cell, "b"]],
+                [:row, 
+                  [:cell, "c"], 
+                  [:cell, "d"]]]]]]
+        end
+
+        it "should have examples" do
+          parse("Feature: Hi
+
+  Scenario Outline: Hello
+
+  Given I have a table
+    |1|2|
+
+  Examples:
+|x|y|
+|5|6|
+
+").to_sexp.should ==
+          [:feature, "Feature: Hi",
+            [:scenario_outline, "Scenario Outline:", "Hello",
+              [:step, 5, "Given", "I have a table",
+                [:table,
+                  [:row,
+                    [:cell, "1"],
+                    [:cell, "2"]]]],
+              [:examples, "Examples:", "",
+                [:table,
+                  [:row,
+                    [:cell, "x"],
+                    [:cell, "y"]],
+                  [:row,
+                    [:cell, "5"],
+                    [:cell, "6"]]]]]]
+        end
+
+        it "should set line numbers on feature" do
+          feature = parse_file("empty_feature.feature:11:12")
+          feature.instance_variable_get('@lines').should == [11, 12]
+        end
+      end
+
+      describe "Syntax" do
+        it "should parse empty_feature" do
+          parse_file("empty_feature.feature")
+        end
+
+        it "should parse empty_scenario" do
+          parse_file("empty_scenario.feature")
+        end
+
+        it "should parse empty_scenario_outline" do
+          parse_file("empty_scenario_outline.feature")
+        end
+
+        it "should parse fit_scenario" do
+          parse_file("multiline_steps.feature")
+        end
+
+        it "should parse scenario_outline" do
+          parse_file("scenario_outline.feature")
+        end
+      end
+    end
+  end
+end

data/spec/cucumber/parser/table_parser_spec.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+require 'treetop'
+require 'cucumber/parser'
+
+module Cucumber
+  module Parser
+    describe 'Tables' do
+      before do
+        @parser = FeatureParser.new
+      end
+      
+      def parse(text)
+        @parser.__send__(:prepare_to_parse, text)
+        @parser.root = :table
+        table = @parser._nt_table
+        table.raw
+      end
+
+      it "should parse a 1x2 table with newline" do
+        parse(" | 1 | 2 | \n").should == [%w{1 2}]
+      end
+
+      it "should parse a 1x2 table without newline" do
+        parse("| 1 | 2 |").should == [%w{1 2}]
+      end
+
+      it "should parse a 1x2 table without spaces" do
+        parse("|1|2|").should == [%w{1 2}]
+      end
+
+      it "should parse a 2x2 table" do
+        parse("| 1 | 2 |\n| 3 | 4 |\n").should == [%w{1 2}, %w{3 4}]
+      end
+
+      it "should parse a 2x2 table with several newlines" do
+        parse("| 1 | 2 |\n| 3 | 4 |\n\n\n").should == [%w{1 2}, %w{3 4}]
+      end
+
+      it "should parse a 2x2 table with empty cells" do
+        parse("| 1 |  |\n|| 4 |\n").should == [['1', nil], [nil, '4']]
+      end
+
+      it "should not parse a 2x2 table that isn't closed" do
+        parse("| 1 |  |\n|| 4 ").should_not == [['1', nil], [nil, '4']]
+      end
+    end
+  end
+end

data/spec/cucumber/rails/stubs/mini_rails.rb

@@ -0,0 +1,18 @@
+# Define some stubs to fake Rails...
+module ActiveRecord
+  class Base
+  end
+end
+
+module ActionController
+  class Dispatcher
+  end
+
+  class Base
+  end
+
+  class IntegrationTest
+    def self.use_transactional_fixtures=(x)
+    end
+  end
+end

data/spec/cucumber/rails/stubs/test_help.rb

@@ -0,0 +1 @@
+# This file is loaded by rails/world.rb

data/spec/cucumber/rails/world_spec.rb

@@ -0,0 +1,11 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+$:.unshift(File.dirname(__FILE__) + '/stubs')
+
+describe "Rails world" do
+
+  it "should run without Test::Unit.run defined" do
+    require "mini_rails"
+    require "cucumber/rails/world"
+  end
+
+end

data/spec/cucumber/sell_cucumbers.feature

@@ -0,0 +1,19 @@
+Feature: Sell cucumbers
+  As a cucumber farmer
+  I want to sell cucumbers
+  So that I buy meat
+
+  Scenario: Sell a dozen
+    Given there are 5 cucumbers
+    When I sell 12 cucumbers
+    Then I should owe 7 cucumbers
+
+  Scenario: Sell twenty
+    Given there are 5 cucumbers
+    When I sell 20 cucumbers
+    Then I should owe 15 cucumbers
+
+  Scenario: Sell fifty
+    Given there are 5 cucumbers
+    When I sell 50 cucumbers
+    Then I should owe 45 cucumbers

data/spec/cucumber/step_definition_spec.rb

@@ -0,0 +1,62 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+require 'cucumber/ast'
+require 'cucumber/step_mother'
+require 'cucumber/step_definition'
+
+module Cucumber
+  describe StepDefinition do
+    before do
+      extend StepMother
+      @world = new_world
+      $inside = nil
+    end
+
+    it "should allow calling of other steps" do
+      Given /Outside/ do
+        Given "Inside"
+      end
+      Given /Inside/ do
+        $inside = true
+      end
+
+      step_definition("Outside").execute(nil, @world)
+      $inside.should == true
+    end
+
+    it "should allow calling of other steps with inline arg" do
+      Given /Outside/ do
+        Given "Inside", Ast::Table.new([['inside']])
+      end
+      Given /Inside/ do |table|
+        $inside = table.raw[0][0]
+      end
+
+      step_definition("Outside").execute(nil, @world)
+      $inside.should == 'inside'
+    end
+
+    it "should raise Undefined when inside step is not defined" do
+      Given /Outside/ do
+        Given 'Inside'
+      end
+
+      step = mock('Step')
+      step.should_receive(:exception=)
+      lambda do
+        @world.__cucumber_current_step = step
+        step_definition('Outside').execute(nil, @world)
+      end.should raise_error(StepMother::Undefined, 'Undefined step: "Inside"')
+    end
+
+    it "should allow forced pending" do
+      Given /Outside/ do
+        pending("Do me!")
+      end
+
+      lambda do
+        step_definition("Outside").execute(nil, @world)
+      end.should raise_error(StepMother::Pending, "Do me!")
+    end
+  end
+end

data/spec/cucumber/treetop_parser/empty_feature.feature

@@ -0,0 +1,4 @@
+Feature: No scenarios yet
+  In order to ...
+  As a ...
+  I want to ...

data/spec/cucumber/treetop_parser/empty_scenario.feature

@@ -0,0 +1,9 @@
+Feature: Empty scenarios should work
+
+  Scenario: Complete scenario
+    Given a valid API key
+
+  Scenario: Will write at somepoint
+
+  Scenario: Another Complete scenario
+    Given an invalid API key

data/spec/cucumber/treetop_parser/empty_scenario_outline.feature

@@ -0,0 +1,3 @@
+Feature: Empty scenarios outlines should work
+
+  Scenario Outline: Implement me please

data/spec/cucumber/treetop_parser/fit_scenario.feature

@@ -0,0 +1,8 @@
+Some title  
+
+  Scenario: second  
+    Given 'bind me please'
+  
+  More Examples:
+  |c|
+  |I can have spaces|

data/spec/cucumber/treetop_parser/given_scenario.feature

@@ -0,0 +1,9 @@
+Some title  
+
+  Scenario: first     
+    Given a
+    Given b
+   
+  Scenario: second  
+    GivenScenario: first
+    Given c