lucid 0.4.1 → 0.5.1

data/spec/lucid/ansicolor_spec.rb

@@ -1,31 +0,0 @@
-require_relative '../spec_helper'
-
-module Lucid
-  module Formatter
-    describe ANSIColor do
-      include ANSIColor
-      
-      it 'should wrap passed_param with bold green and reset to green' do
-        passed_param('test').should == "\e[32m\e[1mtest\e[0m\e[0m\e[32m"
-      end
-
-      it 'should wrap passed in green' do
-        passed('test').should == "\e[32mtest\e[0m"
-      end
-
-      it 'should not reset passed if there are no arguments' do
-        passed.should == "\e[32m"
-      end
-
-      it 'should wrap comments in grey' do
-        comment('test').should == "\e[90mtest\e[0m"
-      end
-
-      it 'should not generate ansi codes when colors are disabled' do
-        ::Lucid::Term::ANSIColor.coloring = false
-        passed('test').should == 'test'
-      end
-      
-    end
-  end
-end

data/spec/lucid/app_spec.rb

@@ -1,82 +0,0 @@
-require 'spec_helper'
-require 'lucid/spec_builder'
-require 'gherkin/formatter/model'
-
-module Lucid
-  module CLI
-    describe App do
-
-      let(:args)   { [] }
-      let(:stdin)  { StringIO.new }
-      let(:stdout) { StringIO.new }
-      let(:stderr) { StringIO.new }
-      let(:kernel) { double(:kernel) }
-      subject { App.new(args, stdin, stdout, stderr, kernel) }
-
-      describe 'start' do
-        context 'passed a runtime' do
-          let(:runtime) { double('runtime').as_null_object }
-
-          def do_start
-            subject.start!(runtime)
-          end
-
-          it 'configures the runtime' do
-            configuration = double('Configuration').as_null_object
-            Context.stub(:new => configuration)
-            runtime.should_receive(:configure).with(configuration)
-            kernel.should_receive(:exit).with(1)
-            do_start
-          end
-
-          it 'uses that runtime for running and reporting results' do
-            results = double('results', :failure? => true)
-            runtime.should_receive(:execute)
-            runtime.stub(:results).and_return(results)
-            kernel.should_receive(:exit).with(1)
-            do_start
-          end
-        end
-
-        context 'execution is interrupted' do
-          after do
-            Lucid.wants_to_quit = false
-          end
-
-          it 'should register as a failure' do
-            results = double('results', :failure? => false)
-            runtime = ContextLoader.any_instance
-            runtime.stub(:excute)
-            runtime.stub(:results).and_return(results)
-
-            Lucid.wants_to_quit = true
-            kernel.should_receive(:exit).with(1)
-            subject.start!
-          end
-        end
-      end
-
-      describe 'verbose execution' do
-        before(:each) do
-          b = Lucid::Parser::SpecBuilder.new('specs/test.spec')
-          b.feature(Gherkin::Formatter::Model::Feature.new([], [], 'Feature', 'Testing', '', 99, ''))
-          b.language = double
-          @empty_feature = b.result
-        end
-
-        it 'should show the spec files that were parsed' do
-          cli = App.new(%w{--verbose test.spec}, stdin, stdout, stderr, kernel)
-          cli.stub(:require)
-
-          Lucid::SpecFile.stub(:new).and_return(double('spec file', :parse => @empty_feature))
-          kernel.should_receive(:exit).with(0)
-
-          cli.start!
-
-          stdout.string.should include('test.spec')
-        end
-      end
-
-    end
-  end
-end

data/spec/lucid/ast/background_spec.rb

@@ -1,128 +0,0 @@
-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::ContextLoader.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 = Walker.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

@@ -1,36 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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::ContextLoader.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::ContextLoader.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

@@ -1,21 +0,0 @@
-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

@@ -1,81 +0,0 @@
-require 'spec_helper'
-
-require 'lucid/ast'
-require 'lucid/lang_extend'
-require 'lucid/interface_rb/rb_language'
-
-module Lucid
-  module AST
-
-    describe ScenarioOutline do
-
-      before do
-        @runtime = Lucid::ContextLoader.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 = Walker.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