cucumber-core 0.1.0

data/spec/cucumber/core/test/mapper_spec.rb

@@ -0,0 +1,68 @@
+require 'cucumber/core/test/mapper'
+require 'cucumber/core/test/case'
+require 'cucumber/core/test/step'
+
+module Cucumber
+  module Core
+    module Test
+      describe Mapper do
+
+        ExampleMappings = Struct.new(:app) do
+          def test_step(test_step, mapper)
+            mapper.map { app.do_something } if test_step.name == 'mapped'
+          end
+        end
+
+        let(:mapper)   { Mapper.new(mappings, receiver) }
+        let(:receiver) { double('receiver') }
+        before         { receiver.stub(:test_case).and_yield }
+        let(:mappings) { ExampleMappings.new(app) }
+        let(:app)      { double('app') }
+
+        context "an unmapped step" do
+          let(:test_step) { Test::Step.new([double(name: 'unmapped')]) }
+          let(:test_case) { Test::Case.new([test_step], double) }
+
+          it "maps to a step that executes to an undefined result" do
+            expect( receiver ).to receive(:test_step) do |test_step|
+              expect( test_step.name ).to eq 'unmapped'
+              expect( test_step.execute ).to be_undefined
+            end.once.ordered
+            test_case.describe_to mapper
+          end
+        end
+
+        context "a mapped step" do
+          let(:test_step) { Test::Step.new([double(name: 'mapped')]) }
+          let(:test_case) { Test::Case.new([test_step], double) }
+
+          it "maps to a step that executes the block" do
+            expect( receiver ).to receive(:test_step) do |test_step|
+              expect( test_step.name ).to eq 'mapped'
+              expect( app ).to receive(:do_something)
+              test_step.execute
+            end.once.ordered
+            test_case.describe_to mapper
+          end
+        end
+
+        context "a combination" do
+          let(:mapped)   { Test::Step.new([double(name: 'passing')]) }
+          let(:unmapped) { Test::Step.new([double(name: 'unmapped')]) }
+          let(:test_case) { Test::Case.new([mapped, unmapped], double) }
+
+          it "maps each of the test steps" do
+            expect( receiver ).to receive(:test_step) do |test_step|
+              expect( test_step.name ).to eq 'passing'
+            end.once.ordered
+            expect( receiver ).to receive(:test_step) do |test_step|
+              expect( test_step.name ).to eq 'unmapped'
+            end.once.ordered
+            test_case.describe_to mapper
+          end
+        end
+      end
+    end
+  end
+end
+

data/spec/cucumber/core/test/mapping_spec.rb

@@ -0,0 +1,103 @@
+require 'cucumber/core/test/mapping'
+
+module Cucumber
+  module Core
+    module Test
+
+      describe Mapping do
+
+        context "constructed without a block" do
+          it "raises an error" do
+            expect { Mapping.new }.to raise_error(ArgumentError)
+          end
+        end
+
+        context "executing" do
+          it "executes the block passed to the constructor" do
+            executed = false
+            mapping = Mapping.new { executed = true }
+            mapping.execute
+            expect( executed ).to be_true
+          end
+
+          it "returns a passed result if the block doesn't fail" do
+            mapping = Mapping.new {}
+            expect( mapping.execute ).to be_passed
+          end
+
+          it "returns a failed result when the block raises an error" do
+            exception = StandardError.new
+            mapping = Mapping.new { raise exception }
+            result = mapping.execute
+            expect( result ).to be_failed
+            expect( result.exception ).to eq exception
+          end
+
+          it "returns a pending result if a pending error is raised" do
+            exception = Result::Pending.new("TODO")
+            mapping = Mapping.new { raise exception }
+            result = mapping.execute
+            expect( result ).to be_pending
+            expect( result.message ).to eq "TODO"
+          end
+
+          context "recording the duration" do
+            before do
+              time = double
+              Time.stub(now: time)
+              time.stub(:nsec).and_return(946752000, 946752001)
+              time.stub(:to_i).and_return(1377009235, 1377009235)
+            end
+
+            it "records the nanoseconds duration of the execution on the result" do
+              mapping = Mapping.new { }
+              duration = mapping.execute.duration
+              expect( duration ).to eq 1
+            end
+
+            it "records the duration of a failed execution" do
+              mapping = Mapping.new { raise StandardError }
+              duration = mapping.execute.duration
+              expect( duration ).to eq 1
+            end
+          end
+
+        end
+
+        context "skipping" do
+          it "does not execute the block" do
+            executed = false
+            mapping = Mapping.new { executed = true }
+            mapping.skip
+            expect( executed ).to be_false
+          end
+
+          it "returns a skipped result" do
+            mapping = Mapping.new {}
+            expect( mapping.skip ).to be_skipped
+          end
+        end
+      end
+
+      describe UndefinedMapping do
+        let(:mapping) { UndefinedMapping.new }
+        let(:test_step) { double }
+
+        context "executing" do
+          it "returns an undefined result" do
+            expect( mapping.execute ).to be_undefined
+          end
+        end
+
+        context "skipping" do
+          it "returns an undefined result" do
+            expect( mapping.skip ).to be_undefined
+          end
+        end
+
+      end
+
+    end
+  end
+end
+

data/spec/cucumber/core/test/result_spec.rb

@@ -0,0 +1,178 @@
+# -*- encoding: utf-8 -*-
+require 'cucumber/core/test/result'
+
+module Cucumber::Core::Test
+  describe Result do
+
+    let(:visitor) { double('visitor') }
+    let(:args)    { double('args')    }
+
+    describe Result::Passed do
+      subject(:result) { Result::Passed.new(duration) }
+      let(:duration)   { 1 * 1000 * 1000 }
+
+      it "describes itself to a visitor" do
+        expect( visitor ).to receive(:passed).with(args)
+        expect( visitor ).to receive(:duration).with(duration, args)
+        result.describe_to(visitor, args)
+      end
+
+      it "converts to a string" do
+        expect( result.to_s ).to eq "✓"
+      end
+
+      it "has a duration" do
+        expect( result.duration ).to eq duration
+      end
+
+      it "requires the constructor argument" do
+        expect { Result::Passed.new }.to raise_error(ArgumentError)
+      end
+
+      it { expect( result ).to     be_passed    }
+      it { expect( result ).not_to be_failed    }
+      it { expect( result ).not_to be_undefined }
+      it { expect( result ).not_to be_unknown   }
+      it { expect( result ).not_to be_skipped   }
+    end
+
+    describe Result::Failed do
+      subject(:result) { Result::Failed.new(duration, exception) }
+      let(:duration)   { 1 * 1000 * 1000 }
+      let(:exception)  { StandardError.new("error message") }
+
+      it "describes itself to a visitor" do
+        expect( visitor ).to receive(:failed).with(args)
+        expect( visitor ).to receive(:duration).with(duration, args)
+        expect( visitor ).to receive(:exception).with(exception, args)
+        result.describe_to(visitor, args)
+      end
+
+      it "has a duration" do
+        expect( result.duration ).to eq duration
+      end
+
+      it "requires both constructor arguments" do
+        expect { Result::Failed.new }.to raise_error(ArgumentError)
+        expect { Result::Failed.new(duration) }.to raise_error(ArgumentError)
+      end
+
+      it { expect( result ).not_to be_passed    }
+      it { expect( result ).to     be_failed    }
+      it { expect( result ).not_to be_undefined }
+      it { expect( result ).not_to be_unknown   }
+      it { expect( result ).not_to be_skipped   }
+    end
+
+    describe Result::Unknown do
+      subject(:result) { Result::Unknown.new }
+
+      it "doesn't describe itself to a visitor" do
+        visitor = double('never receives anything')
+        result.describe_to(visitor, args)
+      end
+
+      it "has no duration" do
+        expect { result.duration }.to raise_error NoMethodError
+      end
+
+      it { expect( result ).not_to be_passed    }
+      it { expect( result ).not_to be_failed    }
+      it { expect( result ).not_to be_undefined }
+      it { expect( result ).to     be_unknown   }
+      it { expect( result ).not_to be_skipped   }
+    end
+
+    describe Result::Undefined do
+      subject(:result) { Result::Undefined.new }
+
+      it "describes itself to a visitor" do
+        expect( visitor ).to receive(:undefined).with(args)
+        result.describe_to(visitor, args)
+      end
+
+      it { expect( result ).not_to be_passed    }
+      it { expect( result ).not_to be_failed    }
+      it { expect( result ).to     be_undefined }
+      it { expect( result ).not_to be_unknown   }
+      it { expect( result ).not_to be_skipped   }
+    end
+
+    describe Result::Skipped do
+      subject(:result) { Result::Skipped.new }
+
+      it "describes itself to a visitor" do
+        expect( visitor ).to receive(:skipped).with(args)
+        result.describe_to(visitor, args)
+      end
+
+      it "has no duration" do
+        expect { result.duration }.to raise_error NoMethodError
+      end
+
+      it { expect( result ).not_to be_passed    }
+      it { expect( result ).not_to be_failed    }
+      it { expect( result ).not_to be_undefined }
+      it { expect( result ).not_to be_unknown   }
+      it { expect( result ).to     be_skipped   }
+    end
+
+    describe Result::Summary do
+      let(:summary)   { Result::Summary.new }
+      let(:failed)    { Result::Failed.new(10, exception) }
+      let(:passed)    { Result::Passed.new(11) }
+      let(:skipped)   { Result::Skipped.new }
+      let(:unknown)   { Result::Unknown.new }
+      let(:undefined) { Result::Undefined.new }
+      let(:exception) { StandardError.new }
+
+      it "counts failed results" do
+        failed.describe_to summary
+        expect( summary.total_failed ).to eq 1
+        expect( summary.total        ).to eq 1
+      end
+
+      it "counts passed results" do
+        passed.describe_to summary
+        expect( summary.total_passed ).to eq 1
+        expect( summary.total        ).to eq 1
+      end
+
+      it "counts skipped results" do
+        skipped.describe_to summary
+        expect( summary.total_skipped ).to eq 1
+        expect( summary.total         ).to eq 1
+      end
+
+      it "counts undefined results" do
+        undefined.describe_to summary
+        expect( summary.total_undefined ).to eq 1
+        expect( summary.total           ).to eq 1
+      end
+
+      it "doesn't count unknown results" do
+        unknown.describe_to summary
+        expect( summary.total ).to eq 0
+      end
+
+      it "counts combinations" do
+        [passed, passed, failed, skipped, undefined].each { |r| r.describe_to summary }
+        expect( summary.total           ).to eq 5
+        expect( summary.total_passed    ).to eq 2
+        expect( summary.total_failed    ).to eq 1
+        expect( summary.total_skipped   ).to eq 1
+        expect( summary.total_undefined ).to eq 1
+      end
+
+      it "records durations" do
+        [passed, failed].each { |r| r.describe_to summary }
+        expect( summary.durations ).to eq [11, 10]
+      end
+
+      it "records exceptions" do
+        [passed, failed].each { |r| r.describe_to summary }
+        expect( summary.exceptions ).to eq [exception]
+      end
+    end
+  end
+end

data/spec/cucumber/core/test/runner_spec.rb

@@ -0,0 +1,265 @@
+require 'cucumber/core/test/runner'
+require 'cucumber/core/test/case'
+require 'cucumber/core/test/step'
+
+module Cucumber::Core::Test
+  describe Runner do
+
+    let(:test_case) { Case.new(test_steps, source) }
+    let(:source)    { double }
+    let(:runner)    { Runner.new(report) }
+    let(:report)    { double.as_null_object }
+    let(:passing)   { Step.new([double]).map {} }
+    let(:failing)   { Step.new([double]).map { raise exception } }
+    let(:pending)   { Step.new([double]).map { raise Result::Pending.new("TODO") } }
+    let(:undefined) { Step.new([double]) }
+    let(:exception) { StandardError.new('test error') }
+
+    context "reporting the duration of a test case" do
+      before do
+        time = double
+        Time.stub(now: time)
+        time.stub(:nsec).and_return(946752000, 946752001)
+        time.stub(:to_i).and_return(1377009235, 1377009235)
+      end
+
+      context "for a passing test case" do
+        let(:test_steps) { [passing] }
+
+        it "records the nanoseconds duration of the execution on the result" do
+          expect( report ).to receive(:after_test_case) do |reported_test_case, result|
+            expect( result.duration ).to eq 1
+          end
+          test_case.describe_to runner
+        end
+      end
+
+      context "for a failing test case" do
+        let(:test_steps) { [failing] }
+
+        it "records the duration" do
+          expect( report ).to receive(:after_test_case) do |reported_test_case, result|
+            expect( result.duration ).to eq 1
+          end
+          test_case.describe_to runner
+        end
+      end
+    end
+
+    context "reporting the exception that failed a test case" do
+      let(:test_steps) { [failing] }
+      it "sets the exception on the result" do
+        expect( report ).to receive(:after_test_case) do |reported_test_case, result|
+          expect( result.exception ).to eq exception
+        end
+        test_case.describe_to runner
+      end
+    end
+
+    context "with a single case" do
+      context "without steps" do
+        let(:test_steps) { [] }
+
+        it "calls the report before running the case" do
+          expect( report ).to receive(:before_test_case).with(test_case)
+          test_case.describe_to runner
+        end
+
+        it "calls the report after running the case" do
+          expect( report ).to receive(:after_test_case) do |reported_test_case, result|
+            expect( reported_test_case ).to eq test_case
+            expect( result ).to be_unknown
+          end
+          test_case.describe_to runner
+        end
+      end
+
+      context 'with steps' do
+        context 'that all pass' do
+          let(:test_steps) { [ passing, passing ]  }
+
+          it 'reports a passing test case' do
+            expect( report ).to receive(:after_test_case) do |test_case, result|
+              expect( result ).to be_passed
+            end
+            test_case.describe_to runner
+          end
+        end
+
+        context 'an undefined step' do
+          let(:test_steps) { [ undefined ]  }
+
+          it 'reports an undefined test case' do
+            expect( report ).to receive(:after_test_case) do |test_case, result|
+              expect( result ).to be_undefined
+            end
+            test_case.describe_to runner
+          end
+        end
+
+        context 'a pending step' do
+          let(:test_steps) { [ pending ] }
+
+          it 'reports a pending test case' do
+            expect( report ).to receive(:after_test_case) do |test_case, result|
+              expect( result ).to be_pending
+            end
+            test_case.describe_to runner
+          end
+        end
+
+        context 'that fail' do
+          let(:test_steps) { [ failing ] }
+
+          it 'reports a failing test case' do
+            expect( report ).to receive(:after_test_case) do |test_case, result|
+              expect( result ).to be_failed
+            end
+            test_case.describe_to runner
+          end
+        end
+
+        context 'where the first step fails' do
+          let(:test_steps) { [ failing, passing ] }
+
+          it 'reports the first step as failed' do
+            expect( report ).to receive(:after_test_step).with(failing, anything) do |test_step, result|
+              expect( result ).to be_failed
+            end
+            test_case.describe_to runner
+          end
+
+          it 'reports the second step as skipped' do
+            expect( report ).to receive(:after_test_step).with(passing, anything) do |test_step, result|
+              expect( result ).to be_skipped
+            end
+            test_case.describe_to runner
+          end
+
+          it 'reports the test case as failed' do
+            expect( report ).to receive(:after_test_case) do |test_case, result|
+              expect( result ).to be_failed
+              expect( result.exception ).to eq exception
+            end
+            test_case.describe_to runner
+          end
+
+          it 'skips, rather than executing the second step' do
+            expect( passing ).not_to receive(:execute)
+            expect( passing ).to receive(:skip)
+            test_case.describe_to runner
+          end
+        end
+
+      end
+    end
+
+    context 'with multiple test cases' do
+      context 'when the first test case fails' do
+        let(:first_test_case) { Case.new([failing], source) }
+        let(:last_test_case)  { Case.new([passing], source) }
+        let(:test_cases)      { [first_test_case, last_test_case] }
+
+        it 'reports the results correctly for the following test case' do
+          expect( report ).to receive(:after_test_case).with(last_test_case, anything) do |reported_test_case, result|
+            expect( result ).to be_passed
+          end
+
+          test_cases.each { |c| c.describe_to runner }
+        end
+      end
+    end
+
+  end
+
+  describe 'with the dry run strategy'  do
+
+    let(:report) { double(:report).as_null_object }
+    let(:source) { double(:source) }
+    let(:runner) { Runner.new(report, :run_mode => :dry_run) }
+    let(:passing) { Step.new([double]).map {} }
+    let(:undefined) { Step.new([double]) }
+    let(:test_case) { Case.new(test_steps, source) }
+
+    context 'with a passing step' do
+      let(:test_steps) { [passing] }
+
+      it 'reports the test case as skipped' do
+        report.should_receive(:after_test_case) do |test_case, result|
+          result.should be_skipped
+        end
+        test_case.describe_to runner
+      end
+
+      it 'reports the test step has been skipped' do
+        report.should_receive(:after_test_step) do |test_step, result|
+          result.should be_skipped
+        end
+        test_case.describe_to runner
+      end
+    end
+
+    context 'with a undefined step' do
+      let(:test_steps) { [undefined] }
+
+      it 'reports the test case as undefined' do
+        report.should_receive(:after_test_case) do |test_case, result|
+          result.should be_undefined
+        end
+        test_case.describe_to runner
+      end
+
+
+      it 'reports the test step as undefined' do
+        report.should_receive(:after_test_step) do |test_step, result|
+          result.should be_undefined
+        end
+        test_case.describe_to runner
+      end
+    end
+
+    context 'with passing and undefined steps' do
+      let(:test_steps) { [passing, undefined] }
+
+      it 'reports the test case as undefined' do
+        report.should_receive(:after_test_case) do |test_case, result|
+          result.should be_undefined
+        end
+        test_case.describe_to runner
+      end
+
+      it 'reports the passing step as skipped' do
+        report.should_receive(:after_test_step).with(passing, anything) do |test_case, result|
+          result.should be_skipped
+        end
+        test_case.describe_to runner
+      end
+
+      it 'reports the undefined step as undefined' do
+        report.should_receive(:after_test_step).with(undefined, anything) do |test_case, result|
+          result.should be_undefined
+        end
+        test_case.describe_to runner
+      end
+    end
+
+    context 'with multiple test cases' do
+      context 'when the first test case is undefined' do
+        let(:first_test_case) { Case.new([undefined], source) }
+        let(:last_test_case)  { Case.new([passing], source) }
+        let(:test_cases)      { [first_test_case, last_test_case] }
+
+        it 'reports the results correctly for the following test case' do
+          report.
+            should_receive(:after_test_case).
+            with(last_test_case, anything) do |reported_test_case, result|
+            result.should be_skipped
+            end
+
+          test_cases.each { |c| c.describe_to runner }
+        end
+      end
+    end
+  end
+
+end