parallel_tests 1.0.9 → 1.1.0

data/spec/parallel_tests/cli_spec.rb

@@ -1,149 +0,0 @@
-require "spec_helper"
-require "parallel_tests/cli"
-require "parallel_tests/rspec/runner"
-
-
-describe ParallelTests::CLI do
-  subject { ParallelTests::CLI.new }
-
-  describe "#parse_options" do
-    let(:defaults){ {:files => []} }
-
-    def call(*args)
-      subject.send(:parse_options!, *args)
-    end
-
-    it "parses regular count" do
-      call(["-n3"]).should == defaults.merge(:count => 3)
-    end
-
-    it "parses count 0 as non-parallel" do
-      call(["-n0"]).should == defaults.merge(:non_parallel => true)
-    end
-
-    it "parses non-parallel as non-parallel" do
-      call(["--non-parallel"]).should == defaults.merge(:non_parallel => true)
-    end
-
-    it "finds the correct type when multiple are given" do
-      call(["--type", "test", "-t", "rspec"])
-      subject.instance_variable_get(:@runner).should == ParallelTests::RSpec::Runner
-    end
-
-    it "parses nice as nice" do
-      call(["--nice"]).should == defaults.merge(:nice => true)
-    end
-
-    context "parse only-group" do
-      it "group_by should be set to filesize" do
-        call(["--only-group", '1']).should == defaults.merge(:group_by=>:filesize, :only_group => [1])
-      end
-
-      it "raise error when group_by isn't filesize" do
-        expect{
-          call(["--only-group", '1', '--group-by', 'steps'])
-        }.to raise_error(RuntimeError)
-      end
-
-      context "with group_by default to filesize" do
-        let(:defaults_with_filesize){defaults.merge(:group_by => :filesize)}
-
-        it "with multiple groups" do
-          call(["--only-group", '4,5']).should == defaults_with_filesize.merge(:only_group => [4,5])
-        end
-
-        it "with a single group" do
-          call(["--only-group", '4']).should == defaults_with_filesize.merge(:only_group => [4])
-        end
-      end
-    end
-  end
-
-  describe "#load_runner" do
-    it "requires and loads default runner" do
-      subject.should_receive(:require).with("parallel_tests/test/runner")
-      subject.send(:load_runner, "test").should == ParallelTests::Test::Runner
-    end
-
-    it "requires and loads rspec runner" do
-      subject.should_receive(:require).with("parallel_tests/rspec/runner")
-      subject.send(:load_runner, "rspec").should == ParallelTests::RSpec::Runner
-    end
-
-    it "requires and loads runner with underscores" do
-      subject.should_receive(:require).with("parallel_tests/my_test_runner/runner")
-      subject.send(:load_runner, "my_test_runner").should == ParallelTests::MyTestRunner::Runner
-    end
-
-    it "fails to load unfindable runner" do
-      expect{
-        subject.send(:load_runner, "foo").should == ParallelTests::RSpec::Runner
-      }.to raise_error(LoadError)
-    end
-  end
-
-  describe "#final_fail_message" do
-    before do
-      subject.instance_variable_set(:@runner, ParallelTests::Test::Runner)
-    end
-
-    it 'returns a plain fail message if colors are nor supported' do
-      subject.should_receive(:use_colors?).and_return(false)
-      subject.send(:final_fail_message).should ==  "Tests Failed"
-    end
-
-    it 'returns a colorized fail message if colors are supported' do
-      subject.should_receive(:use_colors?).and_return(true)
-      subject.send(:final_fail_message).should == "\e[31mTests Failed\e[0m"
-    end
-  end
-  
-  describe "#run_tests_in_parallel" do
-    context "specific groups to run" do
-      let(:results){ {:stdout => "", :exit_status => 0} }
-      before do
-        subject.should_receive(:load_runner).with("my_test_runner").and_return(ParallelTests::MyTestRunner::Runner)
-        ParallelTests::MyTestRunner::Runner.stub(:test_file_name).and_return("test")
-        ParallelTests::MyTestRunner::Runner.should_receive(:tests_in_groups).and_return([
-          ['aaa','bbb'],
-          ['ccc', 'ddd'],
-          ['eee', 'fff']
-        ])
-        subject.should_receive(:report_results).and_return(nil)
-      end
-
-      it "calls run_tests once when one group specified" do
-        subject.should_receive(:run_tests).once.and_return(results)
-        subject.run(['-n', '3', '--only-group', '1', '-t', 'my_test_runner'])
-      end
-
-      it "calls run_tests twice when two groups are specified" do
-        subject.should_receive(:run_tests).twice.and_return(results)
-        subject.run(['-n', '3', '--only-group', '1,2', '-t', 'my_test_runner'])
-      end
-      
-      it "run only one group specified" do
-        options = {:count=>3, :only_group=>[2], :files=>[], :group_by=>:filesize}
-        subject.should_receive(:run_tests).once.with(['ccc', 'ddd'], 0, 1, options).and_return(results)
-        subject.run(['-n', '3', '--only-group', '2', '-t', 'my_test_runner'])
-      end
-      
-      it "run twice with multiple groups" do
-        options = {:count=>3, :only_group=>[2,3], :files=>[], :group_by=>:filesize}
-        subject.should_receive(:run_tests).once.ordered.with(['ccc', 'ddd'], 0, 1, options).and_return(results)
-        subject.should_receive(:run_tests).once.ordered.with(['eee', 'fff'], 1, 1, options).and_return(results)
-        subject.run(['-n', '3', '--only-group', '2,3', '-t', 'my_test_runner'])
-      end
-    end
-  end
-end
-
-
-
-module ParallelTests
-  module MyTestRunner
-    class Runner
-    end
-  end
-end
-

data/spec/parallel_tests/cucumber/failure_logger_spec.rb

@@ -1,43 +0,0 @@
-require 'spec_helper'
-require 'parallel_tests/gherkin/io'
-require 'parallel_tests/cucumber/failures_logger'
-
-describe ParallelTests::Cucumber::FailuresLogger do
-
-  before do
-    @output = OutputLogger.new([])
-    @output.stub(:write)
-
-    @logger1 = ParallelTests::Cucumber::FailuresLogger.new(nil, @output, nil)
-    @logger2 = ParallelTests::Cucumber::FailuresLogger.new(nil, @output, nil)
-    @logger3 = ParallelTests::Cucumber::FailuresLogger.new(nil, @output, nil)
-
-    @feature1 = mock('feature', :file => "feature/path/to/feature1.feature")
-    @feature2 = mock('feature', :file => "feature/path/to/feature2.feature")
-    @feature3 = mock('feature', :file => "feature/path/to/feature3.feature")
-
-    @logger1.instance_variable_set("@lines", [1, 2, 3])
-    @logger2.instance_variable_set("@lines", [2, 4, 6])
-    @logger3.instance_variable_set("@lines", [3, 6, 9])
-  end
-
-  it "should produce a list of lines for failing scenarios" do
-    @logger1.after_feature(@feature1)
-    @logger2.after_feature(@feature2)
-    @logger3.after_feature(@feature3)
-
-    output_file_contents = @output.output.join("\n").concat("\n")
-
-    output_file_contents.should == <<END
-feature/path/to/feature1.feature:1
-feature/path/to/feature1.feature:2
-feature/path/to/feature1.feature:3
-feature/path/to/feature2.feature:2
-feature/path/to/feature2.feature:4
-feature/path/to/feature2.feature:6
-feature/path/to/feature3.feature:3
-feature/path/to/feature3.feature:6
-feature/path/to/feature3.feature:9
-END
-  end
-end

data/spec/parallel_tests/cucumber/runner_spec.rb

@@ -1,25 +0,0 @@
-require "spec_helper"
-require "parallel_tests/gherkin/runner_behaviour"
-require "parallel_tests/cucumber/runner"
-
-describe ParallelTests::Cucumber::Runner do
-  test_tests_in_groups(ParallelTests::Cucumber::Runner, 'features', ".feature")
-
-  it_should_behave_like 'gherkin runners' do
-    let(:runner_name) {'cucumber'}
-    let(:runner_class){ParallelTests::Cucumber::Runner}
-
-    describe :summarize_results do
-      def call(*args)
-        runner_class().summarize_results(*args)
-      end
-
-      it "collates failing scenarios" do
-        results = ["Failing Scenarios:", "cucumber features/failure:1", "cucumber features/failure:2",
-                   "Failing Scenarios:", "cucumber features/failure:3", "cucumber features/failure:4",
-                   "Failing Scenarios:", "cucumber features/failure:5", "cucumber features/failure:6"]
-        call(results).should == "Failing Scenarios:\ncucumber features/failure:1\ncucumber features/failure:2\ncucumber features/failure:3\ncucumber features/failure:4\ncucumber features/failure:5\ncucumber features/failure:6\n\n"
-      end
-    end
-  end
-end

data/spec/parallel_tests/cucumber/scenarios_spec.rb

@@ -1,69 +0,0 @@
-require 'tempfile'
-require 'parallel_tests/cucumber/scenarios'
-
-module ParallelTests
-  module Cucumber
-    describe Scenarios do
-      describe '.all' do
-        context 'by default' do
-          let(:feature_file) do
-            Tempfile.new('grouper.feature').tap do |feature|
-              feature.write <<-EOS
-                Feature: Grouping by scenario
-
-                  Scenario: First
-                    Given I do nothing
-
-                  Scenario: Second
-                    Given I don't do anything
-              EOS
-              feature.rewind
-            end
-          end
-
-          it 'returns all the scenarios' do
-            scenarios = Scenarios.all([feature_file.path])
-            scenarios.should eq %W(#{feature_file.path}:3 #{feature_file.path}:6)
-          end
-        end
-
-        context 'with tags' do
-          let(:feature_file) do
-            Tempfile.new('grouper.feature').tap do |feature|
-              feature.write <<-EOS
-                Feature: Grouping by scenario
-
-                  @wip
-                  Scenario: First
-                    Given I do nothing
-
-                  Scenario: Second
-                    Given I don't do anything
-
-                  @ignore
-                  Scenario: Third
-                    Given I am ignored
-              EOS
-              feature.rewind
-            end
-          end
-
-          it 'ignores those scenarios' do
-            scenarios = Scenarios.all([feature_file.path], :ignore_tag_pattern => '@ignore, @wip')
-            scenarios.should eq %W(#{feature_file.path}:7)
-          end
-
-          it 'return scenarios with tag' do
-            scenarios = Scenarios.all([feature_file.path], :test_options => '-t @wip')
-            scenarios.should eq %W(#{feature_file.path}:4)
-          end
-
-          it 'return scenarios with negative tag' do
-            scenarios = Scenarios.all([feature_file.path], :test_options => '-t @ignore,~@wip') # @ignore or not @wip
-            scenarios.should eq %W(#{feature_file.path}:7 #{feature_file.path}:11)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/parallel_tests/gherkin/listener_spec.rb

@@ -1,96 +0,0 @@
-require 'parallel_tests/gherkin/listener'
-
-describe ParallelTests::Gherkin::Listener do
-  describe :collect do
-    before(:each) do
-      @listener = ParallelTests::Gherkin::Listener.new
-      @listener.uri("feature_file")
-    end
-
-    it "returns steps count" do
-      3.times {@listener.step(nil)}
-      @listener.collect.should == {"feature_file" => 3}
-    end
-
-    it "counts background steps separately" do
-      @listener.background("background")
-      5.times {@listener.step(nil)}
-      @listener.collect.should == {"feature_file" => 0}
-
-      @listener.scenario("scenario")
-      2.times {@listener.step(nil)}
-      @listener.collect.should == {"feature_file" => 2}
-
-      @listener.scenario("scenario")
-      @listener.collect.should == {"feature_file" => 2}
-
-      @listener.eof
-      @listener.collect.should == {"feature_file" => 12}
-    end
-
-    it "counts scenario outlines steps separately" do
-      @listener.scenario_outline("outline")
-      5.times {@listener.step(nil)}
-      @listener.examples(stub('examples', :rows => Array.new(3)))
-      @listener.collect.should == {"feature_file" => 15}
-
-      @listener.scenario("scenario")
-      2.times {@listener.step(nil)}
-      @listener.collect.should == {"feature_file" => 17}
-
-      @listener.scenario("scenario")
-      @listener.collect.should == {"feature_file" => 17}
-
-      @listener.eof
-      @listener.collect.should == {"feature_file" => 17}
-    end
-
-    it 'counts scenarios that should not be ignored' do
-      @listener.ignore_tag_pattern = nil
-      @listener.scenario( stub('scenario', :tags =>[ stub('tag', :name => '@WIP' )]) )
-      @listener.step(nil)
-      @listener.eof
-      @listener.collect.should == {"feature_file" => 1}
-
-      @listener.ignore_tag_pattern = /@something_other_than_WIP/
-      @listener.scenario( stub('scenario', :tags =>[ stub('tag', :name => '@WIP' )]) )
-      @listener.step(nil)
-      @listener.eof
-      @listener.collect.should == {"feature_file" => 2}
-    end
-
-    it 'does not count scenarios that should be ignored' do
-      @listener.ignore_tag_pattern = /@WIP/
-      @listener.scenario( stub('scenario', :tags =>[ stub('tag', :name => '@WIP' )]))
-      @listener.step(nil)
-      @listener.eof
-      @listener.collect.should == {"feature_file" => 0}
-    end
-
-    it 'counts outlines that should not be ignored' do
-      @listener.ignore_tag_pattern = nil
-      @listener.scenario_outline( stub('scenario', :tags =>[ stub('tag', :name => '@WIP' )]) )
-      @listener.step(nil)
-      @listener.examples(stub('examples', :rows => Array.new(3)))
-      @listener.eof
-      @listener.collect.should == {"feature_file" => 3}
-
-      @listener.ignore_tag_pattern = /@something_other_than_WIP/
-      @listener.scenario_outline( stub('scenario', :tags =>[ stub('tag', :name => '@WIP' )]) )
-      @listener.step(nil)
-      @listener.examples(stub('examples', :rows => Array.new(3)))
-      @listener.eof
-      @listener.collect.should == {"feature_file" => 6}
-    end
-
-    it 'does not count outlines that should be ignored' do
-      @listener.ignore_tag_pattern = /@WIP/
-      @listener.scenario_outline( stub('scenario', :tags =>[ stub('tag', :name => '@WIP' )]) )
-      @listener.step(nil)
-      @listener.examples(stub('examples', :rows => Array.new(3)))
-      @listener.eof
-      @listener.collect.should == {"feature_file" => 0}
-    end
-
-  end
-end

data/spec/parallel_tests/gherkin/runner_behaviour.rb

@@ -1,216 +0,0 @@
-require "spec_helper"
-require "parallel_tests/gherkin/runner"
-
-shared_examples_for 'gherkin runners' do
-  describe :run_tests do
-    before do
-      ParallelTests.stub!(:bundler_enabled?).and_return false
-      File.stub!(:file?).with('.bundle/environment.rb').and_return false
-      File.stub!(:file?).with("script/#{runner_name}").and_return true
-    end
-
-    def call(*args)
-      runner_class().run_tests(*args)
-    end
-
-    def should_run_with(regex)
-      ParallelTests::Test::Runner.should_receive(:execute_command).with { |a, b, c, d| a =~ regex }
-    end
-
-    it "allows to override runner executable via PARALLEL_TESTS_EXECUTABLE" do
-      ENV['PARALLEL_TESTS_EXECUTABLE'] = 'script/custom_rspec'
-      should_run_with /script\/custom_rspec/
-      call(['xxx'], 1, 22, {})
-      ENV.delete('PARALLEL_TESTS_EXECUTABLE')
-    end
-
-    it "permits setting env options" do
-      ParallelTests::Test::Runner.should_receive(:execute_command).with { |a, b, c, options|
-        options[:env]["TEST"] == "ME"
-      }
-      call(['xxx'], 1, 22, {:env => {'TEST' => 'ME'}})
-    end
-
-    it "runs bundle exec {runner_name} when on bundler 0.9" do
-      ParallelTests.stub!(:bundler_enabled?).and_return true
-      should_run_with %r{bundle exec #{runner_name}}
-      call(['xxx'], 1, 22, {})
-    end
-
-    it "runs script/{runner_name} when script/{runner_name} is found" do
-      should_run_with %r{script/#{runner_name}}
-      call(['xxx'], 1, 22, {})
-    end
-
-    it "runs {runner_name} by default" do
-      File.stub!(:file?).with("script/#{runner_name}").and_return false
-      should_run_with %r{^#{runner_name}}
-      call(['xxx'], 1, 22, {})
-    end
-
-    it "uses bin/{runner_name} when present" do
-      File.stub(:exists?).with("bin/#{runner_name}").and_return true
-      should_run_with %r{bin/#{runner_name}}
-      call(['xxx'], 1, 22, {})
-    end
-
-    it "uses options passed in" do
-      should_run_with %r{script/#{runner_name} .* -p default}
-      call(['xxx'], 1, 22, :test_options => '-p default')
-    end
-
-    it "sanitizes dangerous file runner_names" do
-      should_run_with %r{xx\\ x}
-      call(['xx x'], 1, 22, {})
-    end
-
-    context "with parallel profile in config/{runner_name}.yml" do
-      before do
-        file_contents = 'parallel: -f progress'
-        Dir.stub(:glob).and_return ["config/#{runner_name}.yml"]
-        File.stub(:read).with("config/#{runner_name}.yml").and_return file_contents
-      end
-
-      it "uses parallel profile" do
-        should_run_with %r{script/#{runner_name} .* foo bar --profile parallel xxx}
-        call(['xxx'], 1, 22, :test_options => 'foo bar')
-      end
-
-      it "uses given profile via --profile" do
-        should_run_with %r{script/#{runner_name} .* --profile foo xxx$}
-        call(['xxx'], 1, 22, :test_options => '--profile foo')
-      end
-
-      it "uses given profile via -p" do
-        should_run_with %r{script/#{runner_name} .* -p foo xxx$}
-        call(['xxx'], 1, 22, :test_options => '-p foo')
-      end
-    end
-
-    it "does not use parallel profile if config/{runner_name}.yml does not contain it" do
-      file_contents = 'blob: -f progress'
-      should_run_with %r{script/#{runner_name} .* foo bar}
-      Dir.should_receive(:glob).and_return ["config/#{runner_name}.yml"]
-      File.should_receive(:read).with("config/#{runner_name}.yml").and_return file_contents
-      call(['xxx'], 1, 22, :test_options => 'foo bar')
-    end
-
-    it "does not use the parallel profile if config/{runner_name}.yml does not exist" do
-      should_run_with %r{script/#{runner_name}} # TODO this test looks useless...
-      Dir.should_receive(:glob).and_return []
-      call(['xxx'], 1, 22, {})
-    end
-  end
-
-  describe :line_is_result? do
-    it "should match lines with only one scenario" do
-      line = "1 scenario (1 failed)"
-      runner_class().line_is_result?(line).should be_true
-    end
-
-    it "should match lines with multiple scenarios" do
-      line = "2 scenarios (1 failed, 1 passed)"
-      runner_class().line_is_result?(line).should be_true
-    end
-
-    it "should match lines with only one step" do
-      line = "1 step (1 failed)"
-      runner_class().line_is_result?(line).should be_true
-    end
-
-    it "should match lines with multiple steps" do
-      line = "5 steps (1 failed, 4 passed)"
-      runner_class().line_is_result?(line).should be_true
-    end
-
-    it "should not match other lines" do
-      line = '    And I should have "2" emails                                # features/step_definitions/user_steps.rb:25'
-      runner_class().line_is_result?(line).should be_false
-    end
-  end
-
-  describe :find_results do
-    it "finds multiple results in test output" do
-      output = <<EOF
-And I should not see "/en/"                                       # features/step_definitions/webrat_steps.rb:87
-
-7 scenarios (3 failed, 4 passed)
-33 steps (3 failed, 2 skipped, 28 passed)
-/apps/rs/features/signup.feature:2
-    Given I am on "/"                                           # features/step_definitions/common_steps.rb:12
-    When I click "register"                                     # features/step_definitions/common_steps.rb:6
-    And I should have "2" emails                                # features/step_definitions/user_steps.rb:25
-
-4 scenarios (4 passed)
-40 steps (40 passed)
-
-And I should not see "foo"                                       # features/step_definitions/webrat_steps.rb:87
-
-1 scenario (1 passed)
-1 step (1 passed)
-
-EOF
-      runner_class().find_results(output).should == ["7 scenarios (3 failed, 4 passed)", "33 steps (3 failed, 2 skipped, 28 passed)", "4 scenarios (4 passed)", "40 steps (40 passed)", "1 scenario (1 passed)", "1 step (1 passed)"]
-    end
-  end
-
-  describe :summarize_results do
-    def call(*args)
-      runner_class().summarize_results(*args)
-    end
-
-    it "sums up results for scenarios and steps separately from each other" do
-      results = ["7 scenarios (3 failed, 4 passed)", "33 steps (3 failed, 2 skipped, 28 passed)", "4 scenarios (4 passed)",
-                 "40 steps (40 passed)", "1 scenario (1 passed)", "1 step (1 passed)"]
-      call(results).should == "12 scenarios (3 failed, 9 passed)\n74 steps (3 failed, 2 skipped, 69 passed)"
-    end
-
-    it "adds same results with plurals" do
-      results = ["1 scenario (1 passed)", "2 steps (2 passed)",
-                 "2 scenarios (2 passed)", "7 steps (7 passed)"]
-      call(results).should == "3 scenarios (3 passed)\n9 steps (9 passed)"
-    end
-
-    it "adds non-similar results" do
-      results = ["1 scenario (1 passed)", "1 step (1 passed)",
-                 "2 scenarios (1 failed, 1 pending)", "2 steps (1 failed, 1 pending)"]
-      call(results).should == "3 scenarios (1 failed, 1 pending, 1 passed)\n3 steps (1 failed, 1 pending, 1 passed)"
-    end
-
-    it "does not pluralize 1" do
-      call(["1 scenario (1 passed)", "1 step (1 passed)"]).should == "1 scenario (1 passed)\n1 step (1 passed)"
-    end
-  end
-
-  describe 'grouping by scenarios for cucumber' do
-    def call(*args)
-      ParallelTests::Gherkin::Runner.send(:run_tests, *args)
-    end
-
-    it 'groups cucumber invocation by feature files to achieve correct cucumber hook behaviour' do
-
-      test_files = %w(features/a.rb:23 features/a.rb:44 features/b.rb:12)
-
-      ParallelTests::Test::Runner.should_receive(:execute_command).with do |a,b,c,d|
-        argv = a.split("--").last.split(" ")[2..-1].sort
-        argv == ["features/a.rb:23:44", "features/b.rb:12"]
-      end
-
-      call(test_files, 1, 2, { :group_by => :scenarios })
-    end
-  end
-
-  describe ".find_tests" do
-    def call(*args)
-      ParallelTests::Gherkin::Runner.send(:find_tests, *args)
-    end
-
-    it "doesn't find bakup files with the same name as test files" do
-      with_files(['a/x.feature','a/x.feature.bak']) do |root|
-        call(["#{root}/"]).should == [
-          "#{root}/a/x.feature",
-        ]
-      end
-    end
-  end
-end