js-log-cucumber 1.0.2

data/spec/cucumber/cli/profile_loader_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'yaml'
+
+module Cucumber
+  module Cli
+    describe ProfileLoader do
+      def given_cucumber_yml_defined_as(hash_or_string)
+        Dir.stub!(:glob).with('{,.config/,config/}cucumber{.yml,.yaml}').and_return(['cucumber.yml'])
+        File.stub!(:exist?).and_return(true)
+        cucumber_yml = hash_or_string.is_a?(Hash) ? hash_or_string.to_yaml : hash_or_string
+        IO.stub!(:read).with('cucumber.yml').and_return(cucumber_yml)
+      end
+
+      def loader
+        ProfileLoader.new
+      end
+
+      it "treats backslashes as literals in rerun.txt when on Windows (JRuby or MRI)" do
+        given_cucumber_yml_defined_as({'default' => '--format "pretty" features\sync_imap_mailbox.feature:16:22'})
+        if(Cucumber::WINDOWS)
+          loader.args_from('default').should == ['--format','pretty','features\sync_imap_mailbox.feature:16:22']
+        else
+          loader.args_from('default').should == ['--format','pretty','featuressync_imap_mailbox.feature:16:22']
+        end
+
+      end
+
+      it "treats forward slashes as literals" do
+        given_cucumber_yml_defined_as({'default' => '--format "ugly" features/sync_imap_mailbox.feature:16:22'})
+        loader.args_from('default').should == ['--format','ugly','features/sync_imap_mailbox.feature:16:22']
+      end
+
+    end
+  end
+end

data/spec/cucumber/configuration_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+module Cucumber
+  describe Configuration do
+    describe ".default" do
+      subject { Configuration.default }
+      
+      it "has an autoload_code_paths containing the standard support and step_definitions folders" do
+        subject.autoload_code_paths.should include('features/support')
+        subject.autoload_code_paths.should include('features/step_definitions')
+      end
+    end
+    
+    describe "with custom user options" do
+      let(:user_options) { { :autoload_code_paths => ['foo/bar/baz'] } }
+      subject { Configuration.new(user_options) }
+      
+      it "allows you to override the defaults" do
+        subject.autoload_code_paths.should == ['foo/bar/baz']
+      end
+    end
+  end
+end

data/spec/cucumber/core_ext/proc_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+require 'cucumber/core_ext/proc'
+
+describe Proc do
+  it "should remove extraneous path info for file" do
+    proc = lambda {|a,b|}
+    proc.file_colon_line.should =~ /^spec\/cucumber\/core_ext\/proc_spec\.rb:6/
+  end
+  
+  it "should raise ArityMismatchError for too many args (expecting 0)" do
+    lambda {
+      Object.new.cucumber_instance_exec(true, 'foo', 1) do
+      end
+    }.should raise_error(Cucumber::ArityMismatchError, "Your block takes 0 arguments, but the Regexp matched 1 argument.")
+  end
+
+  it "should raise ArityMismatchError for too many args (expecting 1)" do
+    lambda {
+      Object.new.cucumber_instance_exec(true, 'foo', 1,2) do |a|
+      end
+    }.should raise_error(Cucumber::ArityMismatchError, "Your block takes 1 argument, but the Regexp matched 2 arguments.")
+  end
+
+  it "should raise ArityMismatchError for too few args (expecting 1)" do
+    lambda {
+      Object.new.cucumber_instance_exec(true, 'foo') do |a|
+      end
+    }.should raise_error(Cucumber::ArityMismatchError, "Your block takes 1 argument, but the Regexp matched 0 arguments.")
+  end
+
+  it "should raise ArityMismatchError for too few args (expecting 2)" do
+    lambda {
+      Object.new.cucumber_instance_exec(true, 'foo', 1) do |a,b|
+      end
+    }.should raise_error(Cucumber::ArityMismatchError, "Your block takes 2 arguments, but the Regexp matched 1 argument.")
+  end
+
+  if Cucumber::RUBY_1_9
+    it "should allow varargs (expecting 0+)" do
+      lambda {
+        Object.new.cucumber_instance_exec(true, 'foo', 1) do |*args|
+        end
+      }.should_not raise_error(Cucumber::ArityMismatchError)
+    end
+  else
+    # Ruby 1.8
+    it "should not allow varargs 0+ because Ruby 1.8 reports same arity as with no args, so we can't really tell the difference." do
+      lambda {
+        Object.new.cucumber_instance_exec(true, 'foo', 1) do |*args|
+        end
+      }.should raise_error(Cucumber::ArityMismatchError, "Your block takes 0 arguments, but the Regexp matched 1 argument.")
+    end
+  end
+
+  it "should allow varargs (expecting 1+)" do
+    lambda {
+      Object.new.cucumber_instance_exec(true, 'foo', 1) do |arg,*args|
+      end
+    }.should_not raise_error(Cucumber::ArityMismatchError)
+  end
+
+  it "should raise ArityMismatchError for too few required args when using varargs (expecting 1+)" do
+    lambda {
+      Object.new.cucumber_instance_exec(true, nil) do |arg,*args|
+      end
+    }.should raise_error(Cucumber::ArityMismatchError, "Your block takes 1+ arguments, but the Regexp matched 0 arguments.")
+  end
+end

data/spec/cucumber/formatter/ansicolor_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'cucumber/formatter/ansicolor'
+
+module Cucumber
+  module Formatter
+    describe ANSIColor do
+      include ANSIColor
+      
+      it "should wrap passed_param with bold green and reset to green" do
+        passed_param("foo").should == "\e[32m\e[1mfoo\e[0m\e[0m\e[32m"
+      end
+
+      it "should wrap passed in green" do
+        passed("foo").should == "\e[32mfoo\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("foo").should == "\e[90mfoo\e[0m"
+      end
+      
+      it "should not generate ansi codes when colors are disabled" do
+        ::Term::ANSIColor.coloring = false
+        passed("foo").should == "foo"
+      end
+    end
+  end
+end

data/spec/cucumber/formatter/duration_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+require 'cucumber/formatter/duration'
+
+module Cucumber
+  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/cucumber/formatter/html_spec.rb

@@ -0,0 +1,256 @@
+require 'spec_helper'
+require 'cucumber/formatter/spec_helper'
+require 'cucumber/formatter/html'
+require 'nokogiri'
+require 'cucumber/rb_support/rb_language'
+
+module Cucumber
+  module Formatter
+
+    describe Html do
+      extend SpecHelperDsl
+      include SpecHelper
+
+      RSpec::Matchers.define :have_css_node do |css, regexp|
+        match do |doc|
+          nodes = doc.css(css)
+          nodes.detect{ |node| node.text =~ regexp }
+        end
+      end
+    
+      before(:each) do
+        @out = StringIO.new
+        @formatter = Html.new(step_mother, @out, {})
+        step_mother.visitor = @formatter
+      end
+    
+      it "should not raise an error when visiting a blank feature name" do
+        lambda { @formatter.feature_name("Feature", "") }.should_not raise_error
+      end
+      
+      describe "given a single feature" do
+        before(:each) do
+          run_defined_feature
+          @doc = Nokogiri.HTML(@out.string)
+        end
+        
+        describe "basic feature" do
+          define_feature <<-FEATURE
+            Feature: Bananas
+              In order to find my inner monkey
+              As a human
+              I must eat bananas
+          FEATURE
+                
+          it "should output a main container div" do
+            @out.string.should =~ /\<div class="cucumber"\>/
+          end
+        end
+        
+        describe "with a comment" do
+          define_feature <<-FEATURE
+            # Healthy
+            Feature: Foo
+          FEATURE
+        
+          it { @out.string.should =~ /^\<!DOCTYPE/ }
+          it { @out.string.should =~ /\<\/html\>$/ }
+          it { @doc.should have_css_node('.feature .comment', /Healthy/) }
+        end
+      
+        describe "with a tag" do
+          define_feature <<-FEATURE
+            @foo
+            Feature: can't have standalone tag :)
+          FEATURE
+
+          it { @doc.should have_css_node('.feature .tag', /foo/) }
+        end
+      
+        describe "with a narrative" do
+          define_feature <<-FEATURE
+            Feature: Bananas
+              In order to find my inner monkey
+              As a human
+              I must eat bananas
+          FEATURE
+
+          it { @doc.should have_css_node('.feature h2', /Bananas/) }
+          it { @doc.should have_css_node('.feature .narrative', /must eat bananas/) }
+        end
+      
+        describe "with a background" do
+          define_feature <<-FEATURE
+            Feature: Bananas
+          
+            Background:
+              Given there are bananas
+          FEATURE
+
+          it { @doc.should have_css_node('.feature .background', /there are bananas/) }
+        end
+      
+        describe "with a scenario" do
+          define_feature <<-FEATURE
+          Feature: Banana party
+
+            Scenario: Monkey eats banana
+              Given there are bananas
+          FEATURE
+
+          it { @doc.should have_css_node('.feature h3', /Monkey eats banana/) }
+          it { @doc.should have_css_node('.feature .scenario .step', /there are bananas/) }
+        end
+      
+        describe "with a scenario outline" do
+          define_feature <<-FEATURE
+          Feature: Fud Pyramid
+
+            Scenario Outline: Monkey eats a balanced diet
+              Given there are <Things>
+          
+              Examples: Fruit
+               | Things  |
+               | apples  |
+               | bananas |
+              Examples: Vegetables
+               | Things   |
+               | broccoli |
+               | carrots  |
+          FEATURE
+        
+          it { @doc.should have_css_node('.feature .scenario.outline h4', /Fruit/) }
+          it { @doc.should have_css_node('.feature .scenario.outline h4', /Vegetables/) }
+          it { @doc.css('.feature .scenario.outline h4').length.should == 2}
+          it { @doc.should have_css_node('.feature .scenario.outline table', //) }
+          it { @doc.should have_css_node('.feature .scenario.outline table td', /carrots/) }
+        end
+      
+        describe "with a step with a py string" do
+          define_feature <<-FEATURE
+          Feature: Traveling circus
+
+            Scenario: Monkey goes to town
+              Given there is a monkey called:
+               """
+               foo
+               """
+          FEATURE
+        
+          it { @doc.should have_css_node('.feature .scenario .val', /foo/) }
+        end
+
+        describe "with a multiline step arg" do
+          define_feature <<-FEATURE
+          Feature: Traveling circus
+
+            Scenario: Monkey goes to town
+              Given there are monkeys:
+               | name |
+               | foo  |
+               | bar  |
+          FEATURE
+        
+          it { @doc.should have_css_node('.feature .scenario table td', /foo/) }
+        end
+      
+        describe "with a table in the background and the scenario" do
+          define_feature <<-FEATURE
+          Feature: accountant monkey
+
+            Background:
+              Given table:
+                | a | b |
+                | c | d |
+            Scenario:
+              Given another table:
+               | e | f |
+               | g | h |
+          FEATURE
+        
+          it { @doc.css('td').length.should == 8 }
+        end
+      
+        describe "with a py string in the background and the scenario" do
+          define_feature <<-FEATURE
+          Feature: py strings
+
+            Background:
+              Given stuff:
+                """
+                foo
+                """
+            Scenario:
+              Given more stuff:
+                """
+                bar
+                """
+          FEATURE
+
+          it { @doc.css('.feature .background pre.val').length.should == 1 }
+          it { @doc.css('.feature .scenario pre.val').length.should == 1 }
+        end
+      
+        describe "with a step that fails in the scenario" do
+          define_steps do
+            Given(/boo/) { raise 'eek' }
+          end
+        
+          define_feature(<<-FEATURE)
+          Feature: Animal Cruelty
+
+            Scenario: Monkey gets a fright
+              Given boo
+            FEATURE
+      
+          it { @doc.should have_css_node('.feature .scenario .step.failed', /eek/) }
+        end
+      
+        describe "with a step that fails in the backgound" do
+          define_steps do
+            Given(/boo/) { raise 'eek' }
+          end
+        
+          define_feature(<<-FEATURE)
+          Feature: shouting
+            Background:
+              Given boo
+            Scenario:
+              Given yay
+            FEATURE
+        
+          it { @doc.should have_css_node('.feature .background .step.failed', /eek/) }
+          it { @doc.should_not have_css_node('.feature .scenario .step.failed', //) }
+          it { @doc.should have_css_node('.feature .scenario .step.undefined', /yay/) }
+        end
+
+        describe "with a step that embeds a snapshot" do
+          define_steps do
+            Given(/snap/) { embed('snapshot.jpeg', 'image/jpeg') }
+          end
+
+          define_feature(<<-FEATURE)
+          Feature: 
+            Scenario:
+              Given snap
+            FEATURE
+
+          it { @doc.css('.embed img').first.attributes['src'].to_s.should == "snapshot.jpeg" }
+        end
+        
+        describe "with an undefined Given step then an undefined And step" do
+          define_feature(<<-FEATURE)
+          Feature: 
+            Scenario:
+              Given some undefined step
+              And another undefined step
+            FEATURE
+            
+          it { @doc.css('pre').map { |pre| /^(Given|And)/.match(pre.text)[1] }.should == ["Given", "Given"] }
+        end
+      
+      end
+    end
+  end
+end
+

data/spec/cucumber/formatter/junit_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+require 'cucumber/formatter/spec_helper'
+
+require 'cucumber/formatter/junit'
+require 'nokogiri'
+
+module Cucumber::Formatter
+  describe Junit do
+    extend SpecHelperDsl
+    include SpecHelper
+    
+    class TestDoubleJunitFormatter < Junit
+      attr_reader :written_files
+      
+      def write_file(feature_filename, data)
+        @written_files ||= {}
+        @written_files[feature_filename] = data
+      end
+    end
+    
+    before(:each) do
+      File.stub!(:directory?).and_return(true)
+      @formatter = TestDoubleJunitFormatter.new(step_mother, '', {})
+    end
+    
+    describe "a feature with no name" do
+      define_feature <<-FEATURE
+        Feature:
+          Scenario: Passing
+            Given a passing scenario
+      FEATURE
+      
+      it "should raise an exception" do
+        lambda { run_defined_feature }.should raise_error(Junit::UnNamedFeatureError)
+      end
+    end
+
+    describe "given a single feature" do
+      before(:each) do
+        run_defined_feature
+        @doc = Nokogiri.XML(@formatter.written_files.values.first)
+      end
+      
+      describe "with a single scenario" do
+        define_feature <<-FEATURE
+          Feature: One passing scenario, one failing scenario
+
+            Scenario: Passing
+              Given a passing scenario
+        FEATURE
+        
+        it { @doc.to_s.should =~ /One passing scenario, one failing scenario/ }
+      end
+
+      describe "with a scenario in a subdirectory" do
+        define_feature %{
+          Feature: One passing scenario, one failing scenario
+
+            Scenario: Passing
+              Given a passing scenario
+        }, File.join('features', 'some', 'path', 'spec.feature')
+
+        it 'writes the filename including the subdirectory' do
+          @formatter.written_files.keys.first.should == File.join('', 'TEST-features-some-path-spec.xml')
+        end
+      end
+      
+      describe "with a scenario outline table" do
+        define_steps do
+          Given(/.*/) {  }
+        end
+        
+        define_feature <<-FEATURE
+          Feature: Eat things when hungry
+
+            Scenario Outline: Eat things
+              Given <Things>
+              And stuff:
+                | foo |
+                | bar |
+            
+            Examples: Good
+              | Things   |
+              | Cucumber |
+              | Whisky   |
+            Examples: Evil
+              | Things   |
+              | Big Mac  |
+        FEATURE
+        
+        it { @doc.to_s.should =~ /Eat things when hungry/ }
+        it { @doc.to_s.should =~ /Cucumber/ }
+        it { @doc.to_s.should =~ /Whisky/ }
+        it { @doc.to_s.should =~ /Big Mac/ }
+        it { @doc.to_s.should_not =~ /Things/ }
+        it { @doc.to_s.should_not =~ /Good|Evil/ }
+        it { @doc.to_s.should_not =~ /type="skipped"/}
+      end
+  
+      describe "with a regular data table scenario" do
+        define_steps do
+          Given(/the following items on a shortlist/) { |table| }  
+          When(/I go.*/) {  }
+          Then(/I should have visited at least/) { |table| } 
+        end
+        
+        define_feature <<-FEATURE
+          Feature: Shortlist
+
+            Scenario: Procure items 
+              Given the following items on a shortlist:
+                | item    |       
+                | milk    |       
+                | cookies |
+              When I get some..
+              Then I'll eat 'em
+           
+        FEATURE
+        # these type of tables shouldn't crash (or generate test cases)
+        it { @doc.to_s.should_not =~ /milk/ }
+        it { @doc.to_s.should_not =~ /cookies/ }
+      end
+    end
+  end
+end