lucid 0.2.1 → 0.3.0

data/spec/lucid/duration_spec.rb

@@ -0,0 +1,22 @@
+require_relative '../spec_helper'
+
+module Lucid
+  module Formatter
+    describe Duration do
+      include Duration
+
+      it 'should format ms' do
+        format_duration(0.002103).should == '0m0.002s'
+      end
+
+      it 'should format m' do
+        format_duration(61.002503).should == '1m1.003s'
+      end
+
+      it 'should format h' do
+        format_duration(3661.002503).should == '61m1.003s'
+      end
+      
+    end
+  end
+end

data/spec/lucid/facade_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+module Lucid
+  describe Runtime::Facade do
+    
+    let(:interface) {double('interface')}
+    subject { Runtime::Orchestrator.new(interface,{}) }
+    let(:facade) { Runtime::Facade.new(subject, interface) }
+    
+    it 'should produce AST::Table by #table' do
+      facade.table( %{
+      | study   | phase |
+      | test-01 | I     |
+      | test-02 | II    |
+      } ).should be_kind_of(AST::Table)
+    end
+
+    it 'should produce AST::DocString by #doc_string with default content-type' do
+      str = facade.doc_string('TEST')
+      str.should be_kind_of(AST::DocString)
+      str.content_type.should eq('')
+    end
+
+    it 'should produce AST::DocString by #doc_string with ruby content-type' do
+      str = facade.doc_string('TEST','ruby')
+      str.should be_kind_of(AST::DocString)
+      str.content_type.should eq('ruby')
+    end
+    
+  end
+end

data/spec/lucid/matcher_spec.rb

@@ -0,0 +1,127 @@
+require_relative '../spec_helper'
+
+module Lucid
+  module InterfaceRb
+    describe Matcher do
+      
+      before do
+        @pattern = 'There is a missing step'
+        @multiline_argument_class = nil
+      end
+      
+      let(:code_keyword) { 'Given' }
+
+      let(:matcher) do
+        matcher_class.new(code_keyword, @pattern, @multiline_argument_class)
+      end
+
+      def unindent(s)
+        s.split("\n")[1..-2].join("\n").indent(-10)
+      end
+      
+      describe Matcher::Regexp do
+        let(:matcher_class) { Matcher::Regexp }
+        let(:matcher_text) { matcher.to_s }
+        
+        it 'should wrap matcher patterns in parentheses' do
+          @pattern = 'A "string" with 4 spaces'
+
+          matcher_text.should == unindent(%{
+          Given (/^A "(.*?)" with (\\d+) spaces$/) do |arg1, arg2|
+            pending
+          end
+          })
+        end
+
+        it 'should recognize numbers in name and make an according regexp' do
+          @pattern = 'There are 4 spaces'
+
+          matcher_text.should == unindent(%{
+          Given (/^There are (\\d+) spaces$/) do |arg1|
+            pending
+          end
+          })
+        end
+
+        it 'should recognise a mix of ints, strings and a table' do
+          @pattern = 'There are 9 "lucid" tests in 20 "categories"'
+          @multiline_argument_class = Lucid::AST::Table
+
+          matcher_text.should == unindent(%{
+          Given (/^There are (\\d+) "(.*?)" tests in (\\d+) "(.*?)"$/) do |arg1, arg2, arg3, arg4, table|
+            # table is a Lucid::AST::Table
+            pending
+          end
+          })
+        end
+
+        it "should recognize quotes in name and make according regexp" do
+          @pattern = 'A "lucid" test'
+
+          matcher_text.should == unindent(%{
+          Given (/^A "(.*?)" test$/) do |arg1|
+            pending
+          end
+          })
+        end
+
+        it 'should recognize several quoted words in name and make according regexp and args' do
+          @pattern = 'A "first" and "second" arg'
+
+          matcher_text.should == unindent(%{
+          Given (/^A "(.*?)" and "(.*?)" arg$/) do |arg1, arg2|
+            pending
+          end
+          })
+        end
+
+        it 'should not use quote group when there are no quotes' do
+          @pattern = 'A first arg'
+
+          matcher_text.should == unindent(%{
+          Given (/^A first arg$/) do
+            pending
+          end
+          })
+        end
+
+        it 'should be helpful with tables' do
+          @pattern = 'A "first" arg'
+          @multiline_argument_class = Lucid::AST::Table
+
+          matcher_text.should == unindent(%{
+          Given (/^A "(.*?)" arg$/) do |arg1, table|
+            # table is a Lucid::AST::Table
+            pending
+          end
+          })
+        end
+      end
+
+      describe Matcher::Classic do
+        let(:matcher_class) { Matcher::Classic }
+
+        it 'renders matcher as unwrapped regular expression' do
+          matcher.to_s.should eql unindent(%{
+          Given /^There is a missing step$/ do
+            pending
+          end
+          })
+        end
+      end
+      
+      describe Matcher::Percent do
+        let(:matcher_class) { Matcher::Percent }
+
+        it 'renders matcher as percent-style regular expression' do
+          matcher.to_s.should eql unindent(%{
+          Given %r{^There is a missing step$} do
+            pending
+          end
+          })
+        end
+      end
+      
+    end
+  end
+end

data/spec/lucid/options_spec.rb

@@ -1,4 +1,5 @@
-require_relative '../spec_helper'
+require 'spec_helper'
+require 'lucid/cli/options'
 
 module Lucid
   module CLI
@@ -23,6 +24,13 @@ module Lucid
       def prep_args(args)
         args.is_a?(Array) ? args : args.split(' ')
       end
+
+      def with_this_configuration(info)
+        Dir.stub(:glob).with('{,.config/,config/}lucid{.yml,.yaml}').and_return(['lucid.yml'])
+        File.stub(:exist?).and_return(true)
+        lucid_yml = info.is_a?(Hash) ? info.to_yaml : info
+        IO.stub(:read).with('lucid.yml').and_return(lucid_yml)
+      end
       
       describe 'parsing options' do
         
@@ -37,7 +45,7 @@ module Lucid
         end
 
         context '--version' do
-          it "should display Lucid's version" do
+          it 'should display Lucid version' do
             after_parsing('--version') do
               output_stream.string.should =~ /#{Lucid::VERSION}/
             end
@@ -55,6 +63,20 @@ module Lucid
             end
           end
         end
+
+        context '--i18n' do
+          context "with LANG specified as 'help'" do
+            it 'lists all known languages' do
+              during_parsing '--i18n help' do
+                Kernel.should_receive(:exit)
+              end
+            end
+
+            it 'exits the program' do
+              during_parsing('--i18n help') { Kernel.should_receive(:exit) }
+            end
+          end
+        end
         
         context '-r or --require' do
           it 'should collect all specified files into an array' do
@@ -85,7 +107,7 @@ module Lucid
 
         context '-b or --backtrace' do
           it 'should use a full backtrace during Lucid execution' do
-            during_parsing("-b") do
+            during_parsing('-b') do
               Lucid.should_receive(:use_full_backtrace=).with(true)
             end
           end
@@ -119,6 +141,204 @@ module Lucid
           end
         end
         
+        context '-P or --no-profile' do
+          it 'disables profiles' do
+            with_this_configuration({'default' => '-v --require code_file.rb'})
+
+            after_parsing('-P --require other_code_file.rb') do
+              options[:require].should == ['other_code_file.rb']
+            end
+          end
+
+          it 'notifies the user that the profiles are being disabled' do
+            with_this_configuration({'default' => '-v'})
+
+            after_parsing('--no-profile --require other_code_file.rb') do
+              output_stream.string.should =~ /Disabling profiles.../
+            end
+          end
+        end
+        
+        context '-p PROFILE or --profile PROFILE' do
+          it 'respects --quiet when defined in the profile' do
+            with_this_configuration('test' => '-q')
+
+            options.parse(%w[-p test])
+            options[:matchers].should be_false
+            options[:source].should be_false
+          end
+          
+          it 'uses the default profile passed in during initialization if none is specified by the user' do
+            with_this_configuration({'default' => '--require test_helper'})
+
+            options = Options.new(output_stream, error_stream, :default_profile => 'default')
+            options.parse(%w{--format progress})
+            options[:require].should include('test_helper')
+          end
+
+          it 'merges all unique values from both the command line and the profile' do
+            with_this_configuration('test' => %w[--verbose])
+
+            options.parse(%w[--wip --profile test])
+            options[:wip].should be_true
+            options[:verbose].should be_true
+          end
+
+          it 'gives precedence to the original options spec source path' do
+            with_this_configuration('test' => %w[specs])
+
+            options.parse(%w[test.spec -p test])
+            options[:spec_source].should == %w[test.spec]
+          end
+
+          it 'combines the require files of both' do
+            with_this_configuration('bar' => %w[--require specs -r helper.rb])
+
+            options.parse(%w[--require test.rb -p bar])
+            options[:require].should == %w[test.rb specs helper.rb]
+          end
+
+          it 'combines the tag names of both' do
+            with_this_configuration('test' => %w[-t @smoke])
+
+            options.parse(%w[--tags @wip -p test])
+            options[:tag_expressions].should == ['@wip', '@smoke']
+          end
+
+          it 'only takes the paths from the original options, and disregards the profiles' do
+            with_this_configuration('test' => %w[specs])
+
+            options.parse(%w[test.spec -p test])
+            options[:spec_source].should == ['test.spec']
+          end
+
+          it 'uses the paths from the profile when none are specified originally' do
+            with_this_configuration('test' => %w[test.spec])
+
+            options.parse(%w[-p test])
+            options[:spec_source].should == ['test.spec']
+          end
+
+          it 'combines environment variables from the profile but gives precedence to command line args' do
+            with_this_configuration('test' => %w[BROWSER=firefox DRIVER=mechanize])
+            
+            options.parse(%w[-p test DRIVER=watir CI=jenkins])
+            options[:env_vars].should == {'CI' => 'jenkins', 'BROWSER' => 'firefox', 'DRIVER' => 'watir'}
+          end
+
+          it 'disregards STDOUT formatter defined in profile when another is passed in via command line' do
+            with_this_configuration({'test' => %w[--format standard]})
+
+            options.parse(%w{--format progress --profile test})
+            options[:formats].should == [['progress', output_stream]]
+          end
+
+          it 'includes any non-STDOUT formatters from the profile' do
+            with_this_configuration({'report' => %w[--format html -o results.html]})
+
+            options.parse(%w{--format progress --profile report})
+            options[:formats].should == [['progress', output_stream], ['html', 'results.html']]
+          end
+
+          it 'does not include STDOUT formatters from the profile if there is a STDOUT formatter in command line' do
+            with_this_configuration({'report' => %w[--format html -o results.html --format standard]})
+
+            options.parse(%w{--format progress --profile report})
+            options[:formats].should == [['progress', output_stream], ['html', 'results.html']]
+          end
+
+          it 'includes any STDOUT formatters from the profile if no STDOUT formatter was specified in command line' do
+            with_this_configuration({'report' => %w[--format html]})
+
+            options.parse(%w{--format rerun -o rerun.txt --profile report})
+            options[:formats].should == [['html', output_stream], ['rerun', 'rerun.txt']]
+          end
+
+          it 'assumes all of the formatters defined in the profile when none are specified on command line' do
+            with_this_configuration({'report' => %w[--format progress --format html -o results.html]})
+
+            options.parse(%w{--profile report})
+            options[:formats].should == [['progress', output_stream], ['html', 'results.html']]
+          end
+
+          it 'only reads lucid.yml once' do
+            original_parse_count = $lucid_yml_read_count
+            $lucid_yml_read_count = 0
+            
+            begin
+              with_this_configuration(<<-END
+              <% $lucid_yml_read_count += 1 %>
+              default: --format standard
+              END
+              )
+              options = Options.new(output_stream, error_stream, :default_profile => 'default')
+              options.parse(%w(-f progress))
+
+              $lucid_yml_read_count.should == 1
+            ensure
+              $lucid_yml_read_count = original_parse_count
+            end
+          end
+        end
+        
+        context '-P or --no-profile' do
+          it 'disables profiles' do
+            with_this_configuration({'default' => '-v --require file_specified_in_default_profile.rb'})
+
+            after_parsing('-P --require test_helper.rb') do
+              options[:require].should == ['test_helper.rb']
+            end
+          end
+
+          it 'notifies the user that the profiles are being disabled' do
+            with_this_configuration({'default' => '-v'})
+
+            after_parsing('--no-profile --require test_helper.rb') do
+              output_stream.string.should =~ /Disabling profiles.../
+            end
+          end
+        end
+        
+        context '--matcher-type' do
+          it 'parses the matcher type argument' do
+            after_parsing('--matcher-type classic') do
+              options[:matcher_type].should eql :classic
+            end
+          end
+        end
+
+        it 'assigns any extra arguments as paths to specs' do
+          after_parsing('-f pretty test.spec other_specs') do
+            options[:spec_source].should == ['test.spec', 'other_specs']
+          end
+        end
+
+        it 'does not mistake environment variables as spec paths' do
+          after_parsing('test.spec ENV=ci') do
+            options[:spec_source].should == ['test.spec']
+          end
+        end
+        
+        describe 'dry-run' do
+          it 'should have the default value for matchers' do
+            with_this_configuration({'test' => %w[--dry-run]})
+            options.parse(%w{--dry-run})
+            options[:matchers].should == true
+          end
+
+          it 'should set matchers to false when no-matchers is provided after dry-run' do
+            with_this_configuration({'test' => %w[--dry-run --no-snippets]})
+            options.parse(%w{--dry-run --no-matchers})
+            options[:matchers].should == false
+          end
+
+          it 'should set matchers to false when no-matchers is provided before dry-run' do
+            with_this_configuration({'test' => %w[--no-snippet --dry-run]})
+            options.parse(%w{--no-matchers --dry-run})
+            options[:matchers].should == false
+          end
+        end
+        
       end
       
     end

data/spec/lucid/orchestrator_spec.rb

@@ -0,0 +1,117 @@
+require 'spec_helper'
+
+module Lucid
+  describe Runtime::Orchestrator do
+    let(:options) { {} }
+    let(:interface) { double('interface') }
+    subject { Runtime::Orchestrator.new(interface, options) }
+
+    let(:dsl) do
+      @rb = subject.load_code_language('rb')
+      Object.new.extend(InterfaceRb::RbLucid)
+    end
+
+    it 'should format step names' do
+      dsl.Given(/it (.*) in (.*)/) { |what, month| }
+      dsl.Given(/some other phrase/) { |what, month| }
+
+      format = subject.step_match('it works in lucid').format_args('[%s]')
+      format.should == 'it [works] in [lucid]'
+    end
+
+    it 'should cache step match results' do
+      dsl.Given(/it (.*) in (.*)/) { |what, month| }
+      step_match = subject.step_match('it works in lucid')
+      @rb.should_not_receive :step_matches
+      second_step_match = subject.step_match('it works in lucid')
+      step_match.should equal(second_step_match)
+    end
+
+    
+    describe 'resolving test definition matches' do
+      it 'should raise Undefined error when no test definitions match' do
+        lambda do
+          subject.step_match('Simple Lucid Test')
+        end.should raise_error(Undefined)
+      end
+
+      it 'should raise Ambiguous error with guess hint when multiple test definitions match' do
+        expected_error = %{Ambiguous match of "Simple Lucid Test":
+
+spec/lucid/orchestrator_spec.rb:\\d+:in `/Simple (.*) Test/'
+spec/lucid/orchestrator_spec.rb:\\d+:in `/Simple Lucid (.*)/'
+
+You can run again with --guess to make Lucid be a little more smart about it.
+}
+        dsl.Given(/Simple (.*) Test/) {|app|}
+        dsl.Given(/Simple Lucid (.*)/) {|action|}
+
+        lambda do
+          subject.step_match("Simple Lucid Test")
+        end.should raise_error(Ambiguous, /#{expected_error}/)
+      end
+
+      describe 'when --guess is used' do
+        let(:options) { {:guess => true} }
+
+        it 'should not show --guess hint' do
+          expected_error = %{Ambiguous match of "Simple lucid test":
+
+spec/lucid/orchestrator_spec.rb:\\d+:in `/Simple (.*)/'
+spec/lucid/orchestrator_spec.rb:\\d+:in `/Simple (.*)/'
+
+}
+          dsl.Given(/Simple (.*)/) {|phrase|}
+          dsl.Given(/Simple (.*)/) {|phrase|}
+          
+          lambda do
+            subject.step_match('Simple lucid test')
+          end.should raise_error(Ambiguous, /#{expected_error}/)
+        end
+
+        it 'should pick right test definition when an equal number of capture groups' do
+          right = dsl.Given(/Simple (.*) test/) {|app|}
+          wrong = dsl.Given(/Simple (.*)/) {|phrase|}
+
+          subject.step_match('Simple lucid test').step_definition.should == right
+        end
+
+        it 'should pick right test definition when an unequal number of capture groups' do
+          right = dsl.Given(/Simple (.*) test ran (.*)/) {|app|}
+          wrong = dsl.Given(/Simple (.*)/) {|phrase|}
+
+          subject.step_match('Simple lucid test ran well').step_definition.should == right
+        end
+
+        it 'should pick most specific test definition when an unequal number of capture groups' do
+          general       = dsl.Given(/Simple (.*) test ran (.*)/) {|app|}
+          specific      = dsl.Given(/Simple lucid test ran well/) do; end
+          more_specific = dsl.Given(/^Simple lucid test ran well$/) do; end
+
+          subject.step_match('Simple lucid test ran well').step_definition.should == more_specific
+        end
+
+        it 'should not raise Ambiguous error when multiple test definitions match' do
+          dsl.Given(/Simple (.*) test/) {|app|}
+          dsl.Given(/Simple (.*)/) {|phrase|}
+
+          lambda do
+            subject.step_match('Simple lucid test')
+          end.should_not raise_error
+        end
+
+        it 'should not raise NoMethodError when guessing from multiple test definitions with nil fields' do
+          dsl.Given(/Simple (.*) test( cannot run well)?/) {|app, status|}
+          dsl.Given(/Simple (.*)?/) {|phrase|}
+
+          lambda do
+            subject.step_match('Simple lucid test')
+          end.should_not raise_error
+        end
+        
+      end
+      
+    end
+
+  end
+end