lucid 0.2.1 → 0.3.0

data/spec/lucid/ast/background_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+require 'lucid/ast'
+require 'lucid/interface_rb/rb_language'
+
+module Lucid
+  module AST
+    describe Background do
+
+      let(:language) { double.as_null_object }
+
+      before do
+        extend(Lucid::InterfaceRb::RbLucid)
+        @runtime = Lucid::Runtime.new
+        @rb = @runtime.load_code_language('rb')
+
+        $x = $y = nil
+        Before do
+          $x = 2
+        end
+        Given /y is (\d+)/ do |n|
+          $y = $x * n.to_i
+        end
+
+        @visitor = TDLWalker.new(@runtime)
+
+        @feature = double('feature', :visit? => true, :feature_elements => []).as_null_object
+      end
+
+      it 'should execute Before blocks before background steps' do
+        background = Background.new(
+            language,
+            Location.new('test.spec', 2),
+            comment = Comment.new(''),
+            keyword = '',
+            title = '',
+            description = '',
+            steps = [
+                Step.new(language,Location.new('test.spec', 7), "Given", "y is 5")
+            ]
+        )
+
+        scenario = Scenario.new(
+            language,
+            background,
+            comment = Comment.new(''),
+            tags = Tags.new(98,[]),
+            feature_tags = Tags.new(1,[]),
+            line = 99,
+            keyword = '',
+            title = '',
+            description = '',
+            steps=[]
+        )
+
+        background.feature = @feature
+        background.accept(@visitor)
+        $x.should == 2
+        $y.should == 10
+      end
+
+      describe 'should respond to #name' do
+        it 'with a value' do
+          background = Background.new(
+              language,
+              Location.new('test.spec', 2),
+              comment = Comment.new(''),
+              keyword = '',
+              title = 'background name',
+              description = '',
+              steps=[]
+          )
+
+          lambda{ background.name }.should_not raise_error
+          background.name.should == 'background name'
+        end
+
+        it 'without a value' do
+          background = Background.new(
+              language,
+              comment = Comment.new(''),
+              line = 2,
+              keyword = '',
+              title = '',
+              description = '',
+              steps=[]
+          )
+
+          lambda{ background.name }.should_not raise_error
+        end
+      end
+
+      describe 'failures in a Before hook' do
+        before do
+          Before do
+            raise Exception, 'Exception from Before hook'
+          end
+        end
+
+        it 'should state that the background has failed' do
+          background = Background.new(
+              language,
+              Location.new('test.spec', 2),
+              comment = Comment.new(''),
+              keyword = '',
+              title = '',
+              description = '',
+              steps = [
+                  Step.new(language, Location.new('test.spec', 7), "Given", "y is 5")
+              ]
+          )
+
+          background.feature = @feature
+
+          @visitor.should_receive( :visit_exception ) do |exception, status|
+            exception.should be_instance_of( Exception )
+            exception.message.should == "Exception from Before hook"
+            status.should == :failed
+          end
+
+          lambda{ background.accept(@visitor) }.should_not raise_error
+          background.should be_failed
+        end
+      end
+      
+    end
+  end
+end

data/spec/lucid/ast/doc_string_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+require 'lucid/ast/doc_string'
+
+module Lucid
+  module AST
+    describe DocString do
+
+      describe 'replacing arguments' do
+        before(:each) do
+          @ps = DocString.new("<book>\n<qty>\n", '')
+        end
+
+        it 'should return a new doc_string with arguments replaced with values' do
+          doc_string_with_replaced_arg = @ps.arguments_replaced({'<book>' => 'Leviathan', '<qty>' => '5'})
+          doc_string_with_replaced_arg.to_step_definition_arg.should == "Leviathan\n5\n"
+        end
+
+        it 'should not change the original doc_string' do
+          doc_string_with_replaced_arg = @ps.arguments_replaced({'<book>' => 'Leviathan'})
+          @ps.to_s.should_not include('Leviathan')
+        end
+
+        it 'should replace nil with empty string' do
+          ps = DocString.new("'<book>'", '')
+          doc_string_with_replaced_arg = ps.arguments_replaced({'<book>' => nil})
+          doc_string_with_replaced_arg.to_step_definition_arg.should == "''"
+        end
+
+        it 'should recognise when just a subset of a cell is delimited' do
+          @ps.should have_text('<qty>')
+        end
+      end
+      
+    end
+  end
+end

data/spec/lucid/ast/feature_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+require 'lucid/ast/tdl_factory'
+
+module Lucid
+  module AST
+    describe Feature do
+      include TDLFactory
+      
+      it 'should convert to a symbolic expression' do
+        runtime = Lucid::Runtime.new
+        runtime.load_code_language('rb')
+        dsl = Object.new
+        dsl.extend Lucid::InterfaceRb::RbLucid
+        
+        feature = create_feature(dsl)
+        if Lucid::WINDOWS
+          feature_file_path = 'specs\\test.spec'
+        else
+          feature_file_path = 'specs/test.spec'
+        end
+        
+        feature.to_sexp.should ==
+            [
+                :feature,
+                feature_file_path,
+                'Testing TDL',
+                [:comment, "# Feature Comment Line\n"],
+                [:tag, 'smoke'],
+                [:tag, 'critical'],
+                [:background, 2, 'Background:',
+                 [:step, 3, 'Given', 'a passing step']],
+                [:scenario, 9, 'Scenario:',
+                 'Test Scenario',
+                 [:comment, "   # Scenario Comment Line 1 \n# Scenario Comment Line 2 \n"],
+                 [:tag, 'regression'],
+                 [:tag, 'selenium'],
+                 [:step_invocation, 3, 'Given', 'a passing step'],
+                 [:step_invocation, 10, 'Given', 'a passing step with an inline argument:',
+                  [:table,
+                   [:row, -1,
+                    [:cell, '1'], [:cell, '22'], [:cell, '333']],
+                   [:row, -1,
+                    [:cell, '4444'], [:cell, '55555'], [:cell, '666666']]]],
+                 [:step_invocation, 11, 'Given', 'a working step with an inline argument:',
+                  [:doc_string, "\n Testing with\nLucid tools\n"]],
+                 [:step_invocation, 12, 'Given', 'a non-passing step']]
+            ]
+      end
+
+      it 'should store operating system specific file paths' do
+        runtime = Lucid::Runtime.new
+        runtime.load_code_language('rb')
+        dsl = Object.new
+        dsl.extend Lucid::InterfaceRb::RbLucid
+        feature = create_feature(dsl)
+
+        if Lucid::WINDOWS
+          feature.file.should == 'specs\test.spec'
+        else
+          feature.file.should == 'specs/test.spec'
+        end
+      end
+      
+    end
+  end
+end

data/spec/lucid/ast/outline_table_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+module Lucid::AST
+  describe OutlineTable do
+    describe OutlineTable::ExampleRow do
+      describe 'a header row' do
+        before(:each) do
+          @row = OutlineTable::ExampleRow.new(
+              double('table', :index => 0),
+              [double('cell', :status= => nil, :accept => nil)]
+          )
+        end
+
+        it 'should raise an error if you try to call #failed?' do
+          @row.accept_plain double('visitor', :visit_table_cell => nil)
+          lambda{ @row.failed? }.should raise_error(NoMethodError, /cannot pass or fail/)
+        end
+      end
+    end
+  end
+end

data/spec/lucid/ast/scenario_outline_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+require 'lucid/ast'
+require 'lucid/core_ext/string'
+require 'lucid/interface_rb/rb_language'
+
+module Lucid
+  module AST
+    
+    describe ScenarioOutline do
+      
+      before do
+        @runtime = Lucid::Runtime.new
+        @runtime.load_code_language('rb')
+        @dsl = Object.new
+        @dsl.extend(Lucid::InterfaceRb::RbLucid)
+
+        @dsl.Given(/^there are (\d+) tests$/) do |n|
+          @initial = n.to_i
+        end
+
+        @dsl.When(/^testing (\d+) scenarios$/) do |n|
+          @tested = n.to_i
+        end
+
+        @dsl.Then(/^there should be (\d+) tests$/) do |n|
+          (@initial - @tested).should == n.to_i
+        end
+        
+        @dsl.Then(/^there should be (\d+) tests completed$/) do |n|
+          @tested.should == n.to_i
+        end
+
+        location = AST::Location.new('test.spec', 19)
+        language = double
+
+        @scenario_outline = ScenarioOutline.new(
+            language,
+            location,
+            background=AST::EmptyBackground.new,
+            Comment.new(''),
+            Tags.new(18, []),
+            Tags.new(0, []),
+            'Scenario:', 'Test Outline', '',
+            [
+                Step.new(language, location.on_line(20), 'Given', 'there are <start> tests'),
+                Step.new(language, location.on_line(21), 'When',  'testing <tests> scenarios'),
+                Step.new(language, location.on_line(22), 'Then',  'there should be <left> tests'),
+                Step.new(language, location.on_line(23), 'And',   'there should be <tests> tests completed')
+            ],
+            [
+                [
+                    [
+                        location.on_line(24),
+                        Comment.new("# Testing\n"),
+                        'Examples:',
+                        'First table',
+                        '',
+                        [
+                            %w{start tests left},
+                            %w{12 5 7},
+                            %w{20 6 14}
+                        ]
+                    ],
+                    Gherkin::Formatter::Model::Examples.new(nil, nil, nil, nil, nil, nil, nil, nil)
+                ]
+            ]
+        )
+      end
+
+      it 'should replace all variables and call outline once for each table row' do
+        visitor = TDLWalker.new(@runtime)
+        visitor.should_receive(:visit_table_row).exactly(3).times
+        @scenario_outline.feature = double.as_null_object
+        @scenario_outline.accept(visitor)
+      end
+      
+    end
+    
+  end
+end

data/spec/lucid/ast/specs_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+module Lucid
+  module AST
+    describe Specs do
+      let(:specs) { Specs.new }
+      
+      def parse_feature(gherkin)
+        path    = 'specs/test.spec'
+        builder = Lucid::Parser::TDLBuilder.new(path)
+        parser  = Gherkin::Parser::Parser.new(builder, true, 'root', false)
+        parser.parse(gherkin, path, 0)
+        builder.language = parser.i18n_language
+        feature = builder.result
+        specs.add_feature(feature)
+      end
+      
+      it 'has a step_count' do
+        parse_feature(<<-GHERKIN)
+Feature:
+  Background:
+    Given step 1
+    And step 2
+
+  Scenario:
+    Given step 3
+    And step 4
+    And step 5
+
+  Scenario Outline:
+    Given step <n>
+    And another step
+
+    Examples:
+      | n |
+      | 6 |
+      | 7 |
+
+    Examples:
+      | n |
+      | 8 |
+        GHERKIN
+
+        specs.step_count.should == (2 + 3) + (3 * (2 + 2))
+      end
+    end
+  end
+end

data/spec/lucid/ast/step_invocation_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+require 'lucid/ast/step_invocation'
+
+module Lucid
+  module AST
+    describe StepInvocation do
+      let(:step_invocation) do
+        matched_cells = []
+        StepInvocation.new(double, double, double, matched_cells)
+      end
+
+      describe 'filtering backtraces' do
+        context 'when enabled' do
+          before { Lucid.stub use_full_backtrace: false }
+
+          it "removes lines with 'gems' in the path" do
+            original_backtrace = ['/foo/bar/gems/baz', '/path/to/my/file.rb']
+            exception = StandardError.new
+            exception.set_backtrace(original_backtrace)
+            result = step_invocation.filter_backtrace(exception).backtrace
+            result.should == ['/path/to/my/file.rb']
+          end
+
+          it "removes lines with '.gem' in the path" do
+            original_backtrace = ['/foo/bar/.gem/baz', '/path/to/my/file.rb']
+            exception = StandardError.new
+            exception.set_backtrace(original_backtrace)
+            result = step_invocation.filter_backtrace(exception).backtrace
+            result.should == ['/path/to/my/file.rb']
+          end
+        end
+
+        context 'when disabled' do
+          before { Lucid.stub use_full_backtrace: true }
+
+          it 'return the exception unmodified' do
+            exception = double
+            step_invocation.filter_backtrace(exception).should == exception
+          end
+        end
+      end
+      
+    end
+  end
+end

data/spec/lucid/ast/step_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+require 'lucid/ast'
+require 'lucid/core_ext/string'
+
+module Lucid
+  module AST
+    
+    describe Step do
+      let(:language) { double }
+
+      it 'should replace arguments in name' do
+        step = Step.new(language, 1, 'Given', 'a <status> test')
+
+        invocation_table = Table.new([
+            %w{status build},
+            %w{passing failing}
+                                     ])
+
+        cells = invocation_table.cells_rows[1]
+        step_invocation = step.step_invocation_from_cells(cells)
+
+        step_invocation.name.should == 'a passing test'
+      end
+
+      it 'should use empty string for the replacement of arguments in name when replace value is nil' do
+        step = Step.new(language, 1, 'Given', 'a <status> test')
+        
+        invocation_table = Table.new([
+            %w(status),
+            [nil]
+                                     ])
+
+        cells = invocation_table.cells_rows[1]
+        step_invocation = step.step_invocation_from_cells(cells)
+
+        step_invocation.name.should == 'a  test'
+      end
+
+      it 'should replace arguments in provided table arguments' do
+        arg_table = Table.new([%w{status_<status> type_<type>}])
+        step = Step.new(language, 1, 'Given', 'a <status> test', arg_table)
+
+        invocation_table = Table.new([
+            %w{status type},
+            %w{passing regression}
+                                     ])
+
+        cells = invocation_table.cells_rows[1]
+        step_invocation = step.step_invocation_from_cells(cells)
+
+        step_invocation.instance_variable_get('@multiline_arg').raw.should == [%w{status_passing type_regression}]
+      end
+
+      it 'should replace arguments in a doc string argument' do
+        doc_string = DocString.new('status_<status> type_<type>', '')
+        step = Step.new(language, 1, 'Given', 'a <status> test', doc_string)
+
+        invocation_table = Table.new([
+            %w{status type},
+            %w{passing regression}
+                                     ])
+
+        cells = invocation_table.cells_rows[1]
+        step_invocation = step.step_invocation_from_cells(cells)
+
+        step_invocation.instance_variable_get('@multiline_arg').to_step_definition_arg.should == 'status_passing type_regression'
+      end
+      
+    end
+  end
+end