lucid 0.2.1 → 0.3.0

data/spec/lucid/ast/table_spec.rb

@@ -0,0 +1,265 @@
+require 'spec_helper'
+require 'lucid/ast/table'
+
+module Lucid
+  module AST
+    
+    describe Table do
+      before do
+        @table = Table.new([
+            %w{one four seven},
+            %w{4444 55555 666666}
+                           ])
+
+        def @table.cells_rows; super; end
+        def @table.columns; super; end
+      end
+
+      it 'should have rows' do
+        @table.cells_rows[0].map{|cell| cell.value}.should == %w{one four seven}
+      end
+
+      it 'should have columns' do
+        @table.columns[1].map{|cell| cell.value}.should == %w{four 55555}
+      end
+
+      it 'should have headers' do
+        @table.headers.should == %w{one four seven}
+      end
+
+      it 'should have same cell objects in rows and columns' do
+        @table.cells_rows[1].__send__(:[], 2).should equal(@table.columns[2].__send__(:[], 1))
+      end
+
+      it 'should know about max width of a row' do
+        @table.columns[1].__send__(:width).should == 5
+      end
+
+      it 'should be convertible to an array of hashes' do
+        @table.hashes.should == [
+            {'one' => '4444', 'four' => '55555', 'seven' => '666666'}
+        ]
+      end
+
+      it 'should accept symbols as keys for the hashes' do
+        @table.hashes.first[:one].should == '4444'
+      end
+
+      it 'should return the row values in order' do
+        @table.rows.first.should == %w{4444 55555 666666}
+      end
+
+      describe '#map_column!' do
+        it 'should allow mapping columns' do
+          @table.map_column!('one') { |v| v.to_i }
+          @table.hashes.first['one'].should == 4444
+        end
+
+        it 'applies the block once to each value' do
+          headers = ['header']
+          rows = ['value']
+          table = Table.new [headers, rows]
+          count = 0
+          table.map_column!('header') { |value| count +=1 }
+          table.rows
+          count.should eq rows.size
+        end
+
+        it 'should allow mapping columns and take a symbol as the column name' do
+          @table.map_column!(:one) { |v| v.to_i }
+          @table.hashes.first['one'].should == 4444
+        end
+
+        it 'should allow mapping columns and modify the rows as well' do
+          @table.map_column!(:one) { |v| v.to_i }
+          @table.rows.first.should include(4444)
+          @table.rows.first.should_not include('4444')
+        end
+
+        it 'should pass silently if a mapped column does not exist in non-strict mode' do
+          lambda {
+            @table.map_column!('two', false) { |v| v.to_i }
+            @table.hashes
+          }.should_not raise_error
+        end
+
+        it 'should fail if a mapped column does not exist in strict mode' do
+          lambda {
+            @table.map_column!('two', true) { |v| v.to_i }
+            @table.hashes
+          }.should raise_error('The column named "two" does not exist')
+        end
+
+        it 'should return the table' do
+          (@table.map_column!(:one) { |v| v.to_i }).should == @table
+        end
+      end
+      
+      describe '#match' do
+        before(:each) do
+          @table = Table.new([
+              %w{one four seven},
+              %w{4444 55555 666666}
+                             ])
+        end
+
+        it 'returns nil if headers do not match' do
+          @table.match('does,not,match').should be_nil
+        end
+
+        it 'requires a table: prefix on match' do
+          @table.match('table:one,four,seven').should_not be_nil
+        end
+
+        it 'does not match if no table: prefix on match' do
+          @table.match('one,four,seven').should be_nil
+        end
+      end
+      
+      describe '#transpose' do
+        before(:each) do
+          @table = Table.new([
+              %w{one 1111},
+              %w{two 22222}
+                             ])
+        end
+
+        it 'should be convertible in to an array where each row is a hash' do
+          @table.transpose.hashes[0].should == {'one' => '1111', 'two' => '22222'}
+        end
+      end
+      
+      describe '#rows_hash' do
+        it 'should return a hash of the rows' do
+          table = Table.new([
+              %w{one 1111},
+              %w{two 22222}
+                            ])
+
+          table.rows_hash.should == {'one' => '1111', 'two' => '22222'}
+        end
+
+        it 'should fail if the table does not have two columns' do
+          faulty_table = Table.new([
+              %w{one 1111 abc},
+              %w{two 22222 def}
+                                   ])
+          
+          lambda {
+            faulty_table.rows_hash
+          }.should raise_error('The table must have exactly 2 columns')
+        end
+
+        it 'should support header and column mapping' do
+          table = Table.new([
+              %w{one 1111},
+              %w{two 22222}
+                            ])
+
+          table.map_headers!({ 'two' => 'Two' }) { |header| header.upcase }
+          table.map_column!('two', false) { |val| val.to_i }
+          table.rows_hash.should == { 'ONE' => '1111', 'Two' => 22222 }
+        end
+      end
+
+      describe '#map_headers!' do
+        let(:table) do
+          Table.new([
+              %w{HELLO LUCID},
+              %w{4444 55555}
+                    ])
+        end
+
+        it 'renames the columns to the specified values in the provided hash' do
+          @table.map_headers!('one' => :three)
+          @table.hashes.first[:three].should == '4444'
+        end
+
+        it 'allows renaming columns using regular expressions' do
+          @table.map_headers!(/one|uno/ => :three)
+          @table.hashes.first[:three].should == '4444'
+        end
+
+        it 'copies column mappings' do
+          @table.map_column!('one') { |v| v.to_i }
+          @table.map_headers!('one' => 'three')
+          @table.hashes.first['three'].should == 4444
+        end
+
+        it 'takes a block and operates on all the headers with it' do
+          table.map_headers! do |header|
+            header.downcase
+          end
+          table.hashes.first.keys.should =~ %w[hello lucid]
+        end
+
+        it 'treats the mappings in the provided hash as overrides when used with a block' do
+          table.map_headers!('LUCID' => 'test') do |header|
+            header.downcase
+          end
+          table.hashes.first.keys.should =~ %w[hello test]
+        end
+      end
+
+      describe 'replacing arguments' do
+        before(:each) do
+          @table = Table.new([
+              %w{showings movie},
+              %w{<showings> <movie>}
+                             ])
+        end
+
+        it 'should return a new table with arguments replaced with values' do
+          table_with_replaced_args = @table.arguments_replaced({'<movie>' => 'Gravity', '<showings>' => '5'})
+          table_with_replaced_args.hashes[0]['movie'].should == 'Gravity'
+          table_with_replaced_args.hashes[0]['showings'].should == '5'
+        end
+
+        it 'should recognise when entire cell is delimited' do
+          @table.should have_text('<movie>')
+        end
+
+        it 'should recognise when just a subset of a cell is delimited' do
+          table = Table.new([
+              %w{showings movie},
+              [nil, "Seeing <director>'s movie"]
+                            ])
+
+          table.should have_text('<director>')
+        end
+
+        it 'should replace nil values with nil' do
+          table_with_replaced_args = @table.arguments_replaced({'<movie>' => nil})
+          table_with_replaced_args.hashes[0]['movie'].should == nil
+        end
+
+        it 'should preserve values which do not match a placeholder when replacing with nil' do
+          table = Table.new([
+              %w{movie},
+              %w{screenplay}
+                            ])
+          table_with_replaced_args = table.arguments_replaced({'<movie>' => nil})
+          table_with_replaced_args.hashes[0]['movie'].should == 'screenplay'
+        end
+
+        it 'should not change the original table' do
+          @table.arguments_replaced({'<movie>' => 'Gravity'})
+          @table.hashes[0]['movie'].should_not == 'Gravity'
+        end
+
+        it 'should not raise an error when there are nil values in the table' do
+          table = Table.new([
+              ['movie', 'showings'],
+              ['<movie', nil]
+                            ])
+          
+          lambda {
+            table.arguments_replaced({'<movie>' => nil, '<showings>' => '5'})
+          }.should_not raise_error
+        end
+      end
+      
+    end
+    
+  end
+end

data/spec/lucid/ast/tdl_factory.rb

@@ -0,0 +1,78 @@
+require 'lucid/ast'
+
+module Lucid
+  module AST
+    module TDLFactory
+
+      class TestDomain
+
+      end
+
+      def create_feature(dsl)
+        dsl.Given (/^a (.*) step with an inline argument:$/) do |action, table|
+        end
+
+        dsl.Given (/^a (.*) step$/) do |action|
+        end
+
+        dsl.Domain do
+          TestDomain.new
+        end
+
+        table = AST::Table.new([
+                                   %w{1 22 333},
+                                   %w{4444 55555 666666}
+                               ])
+
+        doc_string = AST::DocString.new(%{\n Testing with\nLucid tools\n}, '')
+        location = AST::Location.new('test.spec', 2)
+        language = double.as_null_object
+
+        background = AST::Background.new(
+            language,
+            location,
+            AST::Comment.new(''),
+            'Background:',
+            '',
+            '',
+            [
+                Step.new(language, location.on_line(3), 'Given', 'a passing step')
+            ]
+        )
+
+        if Lucid::WINDOWS
+          location = Location.new('specs\\test.spec', 0)
+        else
+          location = Location.new('specs/test.spec', 0)
+        end
+
+        AST::Feature.new(
+            location,
+            background,
+            AST::Comment.new("# Feature Comment Line\n"),
+            AST::Tags.new(6, [Gherkin::Formatter::Model::Tag.new('smoke', 6),
+                              Gherkin::Formatter::Model::Tag.new('critical', 6)]),
+            'Feature',
+            'Testing TDL',
+            '',
+            [AST::Scenario.new(
+                 language,
+                 location.on_line(9),
+                 background,
+                 AST::Comment.new("   # Scenario Comment Line 1 \n# Scenario Comment Line 2 \n"),
+                 AST::Tags.new(8, [Gherkin::Formatter::Model::Tag.new('regression', 8),
+                                   Gherkin::Formatter::Model::Tag.new('selenium', 8)]),
+                 AST::Tags.new(1, []),
+                 'Scenario:', 'Test Scenario', '',
+                 [
+                     Step.new(language, location.on_line(10), 'Given', 'a passing step with an inline argument:', table),
+                     Step.new(language, location.on_line(11), 'Given', 'a working step with an inline argument:', doc_string),
+                     Step.new(language, location.on_line(12), 'Given', 'a non-passing step')
+                 ]
+             )]
+        )
+      end
+      
+    end
+  end
+end

data/spec/lucid/ast/tdl_walker_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+module Lucid::AST
+  
+  describe TDLWalker do
+    let(:tdl_walker) do
+      TDLWalker.new(nil, [double('listener', :before_visit_features => nil)])
+    end
+    let(:features) { double('features', :accept => nil) }
+
+    it 'should visit features' do
+      tdl_walker.should_not_receive(:warn)
+      tdl_walker.visit_features(features)
+    end
+
+    it 'should return self' do
+      tdl_walker.visit_features(features).should == tdl_walker
+    end
+  end
+  
+end

data/spec/lucid/configuration_spec.rb

@@ -1,4 +1,4 @@
-require_relative '../spec_helper'
+require 'spec_helper'
 
 module Lucid
   describe Configuration do
@@ -6,9 +6,9 @@ module Lucid
       subject { Configuration.default }
 
       it 'has an autoload_code_paths containing default Lucid folders' do
-        subject.autoload_code_paths.should include('common')
-        subject.autoload_code_paths.should include('steps')
-        subject.autoload_code_paths.should include('pages')
+        subject.autoload_code_paths.should include 'common'
+        subject.autoload_code_paths.should include 'steps'
+        subject.autoload_code_paths.should include 'pages'
       end
     end
 
@@ -24,6 +24,8 @@ module Lucid
   
   module CLI
     describe Configuration do
+
+      attr_reader :out, :error
       
       module ExposeOptions
         attr_reader :options
@@ -39,12 +41,13 @@ module Lucid
         Dir.stub(:[]).and_return(files)
       end
       
-      def with_this_configuration_file(info)
+      def with_this_configuration(info)
+        Dir.stub(:glob).with('{,.config/,config/}lucid{.yml,.yaml}').and_return(['lucid.yml'])
         File.stub(:exist?).and_return(true)
         profile_file = info.is_a?(Hash) ? info.to_yaml : info
         IO.stub(:read).with('lucid.yml').and_return(profile_file)
       end
-      
+
       it 'should require driver.rb files first' do
         with_these_files('/common/support/browser.rb', '/common/support/driver.rb')
         config.parse(%w{--require /common})
@@ -77,17 +80,39 @@ module Lucid
       it 'should default to a specs directory when no information is provided' do
         File.stub(:directory?).and_return(true)
         Dir.stub(:[]).with('specs/**/*.spec').and_return(['lucid.spec'])
+        Dir.stub(:[]).with('specs/**/*.feature').and_return(['lucid.spec'])
+        Dir.stub(:[]).with('specs/**/*.story').and_return(['lucid.spec'])
         config.parse(%w{})
         config.spec_files.should == ['lucid.spec']
       end
       
       it 'should search for all specs in the specified directory' do
         File.stub(:directory?).and_return(true)
-        Dir.stub(:[]).with('specs/**/*.spec').and_return(["lucid.spec"])
+        Dir.stub(:[]).with('specs/**/*.spec').and_return(['lucid.spec'])
+        Dir.stub(:[]).with('specs/**/*.feature').and_return(['lucid.spec'])
+        Dir.stub(:[]).with('specs/**/*.story').and_return(['lucid.spec'])
         config.parse(%w{specs/})
         config.spec_files.should == ['lucid.spec']
       end
-      
+
+      it 'should return the correct spec file type for feature file' do
+        File.stub(:directory?).and_return(true)
+        Dir.stub(:[]).with('specs/**/*.spec').and_return(['lucid.feature'])
+        Dir.stub(:[]).with('specs/**/*.feature').and_return(['lucid.feature'])
+        Dir.stub(:[]).with('specs/**/*.story').and_return(['lucid.feature'])
+        config.parse(%w{specs/})
+        config.spec_files.should == ['lucid.feature']
+      end
+
+      it 'should return the correct spec file type for story file' do
+        File.stub(:directory?).and_return(true)
+        Dir.stub(:[]).with('specs/**/*.spec').and_return(['lucid.story'])
+        Dir.stub(:[]).with('specs/**/*.feature').and_return(['lucid.story'])
+        Dir.stub(:[]).with('specs/**/*.story').and_return(['lucid.story'])
+        config.parse(%w{specs/})
+        config.spec_files.should == ['lucid.story']
+      end
+
       it 'should preserve the order of the spec files' do
         config.parse(%w{test_b.spec test_c.spec test_a.spec})
         config.spec_files.should == %w[test_b.spec test_c.spec test_a.spec]
@@ -142,6 +167,12 @@ module Lucid
         config.parse(%w{--verbose})
         config.options[:verbose].should be_true
       end
+
+      it 'uses the default profile when no profile is defined' do
+        with_this_configuration({'default' => '--require test_file'})
+        config.parse(%w{--format progress})
+        config.options[:require].should include('test_file')
+      end
       
       describe 'generating output' do
       
@@ -167,6 +198,130 @@ module Lucid
         config = Configuration.new(StringIO.new)
         config.parse(['--no-color'])
       end
+
+      it 'should accept multiple --format options and put the STDOUT one first so progress is seen' do
+        config.parse(%w{--format standard --out output.txt --format progress})
+        config.formats.should == [['progress', out], ['standard', 'output.txt']]
+      end
+
+      it 'should not accept multiple --format options when both use implicit STDOUT' do
+        lambda do
+          config.parse(%w{--format pretty --format progress})
+        end.should raise_error('All but one formatter must use --out, only one can print to each stream (or STDOUT)')
+      end
+
+      it 'should accept same --format options with implicit STDOUT, and keep only one' do
+        config.parse(%w{--format standard --format standard})
+        config.formats.should == [['standard', out]]
+      end
+
+      it 'should not accept multiple --out streams pointing to the same place' do
+        lambda do
+          config.parse(%w{--format standard --out file1 --format progress --out file1})
+        end.should raise_error('All but one formatter must use --out, only one can print to each stream (or STDOUT)')
+      end
+
+      it 'should associate --out to previous --format' do
+        config.parse(%w{--format progress --out file1 --format profile --out file2})
+        config.formats.should == [['progress', 'file1'], ['profile', 'file2']]
+      end
+
+      it 'should accept same --format options with same --out streams and keep only one' do
+        config.parse(%w{--format html --out file --format standard --format html --out file})
+        config.formats.should == [['standard', out], ['html', 'file']]
+      end
+
+      it 'should accept same --format options with different --out streams' do
+        config.parse(%w{--format html --out file1 --format html --out file2})
+        config.formats.should == [['html', 'file1'], ['html', 'file2']]
+      end
+
+      it 'should accept multiple --name options' do
+        config.parse(['--name', 'User logs in', '--name', 'User signs up'])
+
+        config.options[:name_regexps].should include(/User logs in/)
+        config.options[:name_regexps].should include(/User signs up/)
+      end
+
+      it 'should accept multiple -n options' do
+        config.parse(['-n', 'User logs in', '-n', 'User signs up'])
+
+        config.options[:name_regexps].should include(/User logs in/)
+        config.options[:name_regexps].should include(/User signs up/)
+      end
+
+      it 'should allow specifying environment variables in profiles' do
+        with_this_configuration({'selenium' => 'DRIVER=selenium'})
+        config.parse(['--profile', 'selenium'])
+        ENV['DRIVER'].should == 'selenium'
+        config.spec_files.should_not include('DRIVER=selenium')
+      end
+
+      describe 'Dry run execution' do
+        it 'returns true when --dry-run was specified on in the arguments' do
+          config.parse(['--dry-run'])
+          config.dry_run?.should be_true
+        end
+
+        it 'returns true when --dry-run was specified in a profile' do
+          with_this_configuration({'default' => '--dry-run'})
+          config.parse([])
+          config.dry_run?.should be_true
+        end
+
+        it 'returns false by default' do
+          config.parse([])
+          config.dry_run?.should be_false
+        end
+      end
+      
+      describe 'Specifying matcher type' do
+        it 'returns the matcher type when it was set' do
+          config.parse(['--matcher-type', 'classic'])
+          config.matcher_type.should eql :classic
+        end
+
+        it 'returns the matcher type when it was set with shorthand option' do
+          config.parse(['-I', 'classic'])
+          config.matcher_type.should eql :classic
+        end
+
+        it 'returns the default matcher type if it was not set' do
+          config.parse([])
+          config.matcher_type.should eql :regexp
+        end
+      end
+
+      describe 'handling tags' do
+        it 'returns an empty expression when no tags are specified' do
+          config.parse([])
+          config.tag_expression.should be_empty
+        end
+
+        it 'returns an expression when tags are specified' do
+          config.parse(['--tags','@smoke'])
+          config.tag_expression.should_not be_empty
+        end
+      end
+
+      describe 'Getting a backtrace of errors' do
+        before do
+          Lucid.use_full_backtrace = false
+        end
+
+        it 'should show full backtrace when --backtrace is called for' do
+          config = App.new(['--backtrace'])
+          begin
+            'x'.should == 'y'
+          rescue => e
+            e.backtrace[0].should_not == "#{__FILE__}:#{__LINE__ - 2}"
+          end
+        end
+        
+        after do
+          Lucid.use_full_backtrace = false
+        end
+      end
       
     end
   end