mobiusloop 0.1.2

data/spec/cucumber/filters/activate_steps_spec.rb

@@ -0,0 +1,149 @@
+require 'cucumber/filters/activate_steps'
+require 'cucumber/core/gherkin/writer'
+require 'cucumber/core'
+
+describe Cucumber::Filters::ActivateSteps do
+  include Cucumber::Core::Gherkin::Writer
+  include Cucumber::Core
+
+  let(:step_match) { double(activate: activated_test_step) }
+  let(:activated_test_step) { double }
+  let(:receiver) { double.as_null_object }
+  let(:filter) { Cucumber::Filters::ActivateSteps.new(step_match_search, configuration) }
+  let(:step_match_search) { Proc.new { [step_match] } }
+  let(:configuration) { double(dry_run?: false, notify: nil) }
+
+  context "a scenario with a single step" do
+    let(:doc) do
+      gherkin do
+        feature do
+          scenario do
+            step 'a passing step'
+          end
+        end
+      end
+    end
+
+    it "activates each step" do
+      expect(step_match).to receive(:activate) do |test_step|
+        expect(test_step.name).to eq 'a passing step'
+      end
+      compile [doc], receiver, [filter]
+    end
+
+    it "notifies with a StepMatch event" do
+      expect(configuration).to receive(:notify) do |event|
+        expect(event.test_step.name).to eq 'a passing step'
+        expect(event.step_match).to eq step_match
+      end
+      compile [doc], receiver, [filter]
+    end
+  end
+
+  context "a scenario outline" do
+    let(:doc) do
+      gherkin do
+        feature do
+          scenario_outline do
+            step 'a <status> step'
+
+            examples do
+              row 'status'
+              row 'passing'
+            end
+          end
+        end
+      end
+    end
+
+    it "activates each step" do
+      expect(step_match).to receive(:activate) do |test_step|
+        expect(test_step.name).to eq 'a passing step'
+      end
+      compile [doc], receiver, [filter]
+    end
+  end
+
+  context "undefined step" do
+    let(:step_match_search) { Proc.new { [] } }
+
+    let(:doc) do
+      gherkin do
+        feature do
+          scenario do
+            step 'an undefined step'
+          end
+        end
+      end
+    end
+
+    it "does not activate the step" do
+      expect(receiver).to receive(:test_case) do |test_case|
+        expect(test_case.test_steps[0].execute).to be_undefined
+      end
+      compile [doc], receiver, [filter]
+    end
+
+    it "does not notify" do
+      expect(configuration).not_to receive(:notify)
+      compile [doc], receiver, [filter]
+    end
+  end
+
+  context "dry run" do
+    let(:configuration) { double(dry_run?: true, notify: nil) }
+
+    let(:doc) do
+      gherkin do
+        feature do
+          scenario do
+            step 'a passing step'
+          end
+        end
+      end
+    end
+
+    it "activates each step with a skipping action" do
+      expect(receiver).to receive(:test_case) do |test_case|
+        expect(test_case.test_steps[0].execute).to be_skipped
+      end
+      compile [doc], receiver, [filter]
+    end
+
+    it "notifies with a StepMatch event" do
+      expect(configuration).to receive(:notify) do |event|
+        expect(event.test_step.name).to eq 'a passing step'
+        expect(event.step_match).to eq step_match
+      end
+      compile [doc], receiver, [filter]
+    end
+  end
+
+  context "undefined step in a dry run" do
+    let(:step_match_search) { Proc.new { [] } }
+    let(:configuration) { double(dry_run?: true, notify: nil) }
+
+    let(:doc) do
+      gherkin do
+        feature do
+          scenario do
+            step 'an undefined step'
+          end
+        end
+      end
+    end
+
+    it "does not activate the step" do
+      expect(receiver).to receive(:test_case) do |test_case|
+        expect(test_case.test_steps[0].execute).to be_undefined
+      end
+      compile [doc], receiver, [filter]
+    end
+
+    it "does not notify" do
+      expect(configuration).not_to receive(:notify)
+      compile [doc], receiver, [filter]
+    end
+  end
+
+end

data/spec/cucumber/filters/gated_receiver_spec.rb

@@ -0,0 +1,47 @@
+require "cucumber/filters/gated_receiver"
+
+describe Cucumber::Filters::GatedReceiver do
+  subject(:gated_receiver) { Cucumber::Filters::GatedReceiver.new(receiver) }
+
+  let(:receiver) { double(:receiver) }
+  let(:test_cases){ [double(:test_case), double(:test_case)] }
+
+  describe "#test_case" do
+    it "does not immediately describe the test case to the receiver" do
+      test_cases.each do |test_case|
+        expect(test_case).to_not receive(:describe_to).with(receiver)
+      end
+
+      test_cases.each do |test_case|
+        gated_receiver.test_case(test_case)
+      end
+    end
+  end
+
+  describe "#done" do
+    before do
+      test_cases.each do |test_case|
+        gated_receiver.test_case(test_case)
+      end
+
+      test_cases.each do |test_case|
+        allow(test_case).to receive(:describe_to).with(receiver)
+      end
+
+      allow(receiver).to receive(:done)
+    end
+
+    it "describes all test cases to the receiver" do
+      test_cases.each do |test_case|
+        expect(test_case).to receive(:describe_to).with(receiver)
+      end
+
+      gated_receiver.done
+    end
+
+    it "calls done on the receiver" do
+      expect(receiver).to receive(:done)
+      gated_receiver.done
+    end
+  end
+end

data/spec/cucumber/filters/retry_spec.rb

@@ -0,0 +1,79 @@
+require 'cucumber'
+require 'cucumber/filters/retry'
+require 'cucumber/core/gherkin/writer'
+require 'cucumber/configuration'
+require 'cucumber/core/test/case'
+require 'cucumber/core'
+require 'cucumber/events'
+
+describe Cucumber::Filters::Retry do
+  include Cucumber::Core::Gherkin::Writer
+  include Cucumber::Core
+  include Cucumber::Events
+
+  let(:configuration) { Cucumber::Configuration.new(:retry => 2) }
+  let(:test_case) { Cucumber::Core::Test::Case.new([double('test steps')], double('source').as_null_object) }
+  let(:receiver) { double('receiver').as_null_object }
+  let(:filter) { Cucumber::Filters::Retry.new(configuration, receiver) }
+  let(:fail) { Cucumber::Events::AfterTestCase.new(test_case, double('result', :failed? => true, :ok? => false)) }
+  let(:pass) { Cucumber::Events::AfterTestCase.new(test_case, double('result', :failed? => false, :ok? => true)) }
+
+  it { is_expected.to respond_to(:test_case) }
+  it { is_expected.to respond_to(:with_receiver) }
+  it { is_expected.to respond_to(:done) }
+
+  context "general" do
+    before(:each) do
+      filter.with_receiver(receiver)
+    end
+
+    it "registers the :after_test_case event" do
+      expect(configuration).to receive(:on_event).with(:after_test_case)
+      filter.test_case(test_case)
+    end
+  end
+
+  context "passing test case" do
+    it "describes the test case once" do
+      expect(test_case).to receive(:describe_to).with(receiver)
+      filter.test_case(test_case)
+      configuration.notify(pass)
+    end
+  end
+
+  context "failing test case" do
+    it "describes the test case the specified number of times" do
+      expect(receiver).to receive(:test_case) {|test_case|
+        configuration.notify(fail)
+      }.exactly(3).times
+
+      filter.test_case(test_case)
+    end
+  end
+
+  context "flaky test cases" do
+
+    context "a little flaky" do
+      it "describes the test case twice" do
+        results = [fail, pass]
+        expect(receiver).to receive(:test_case) {|test_case|
+          configuration.notify(results.shift)
+        }.exactly(2).times
+
+        filter.test_case(test_case)
+      end
+    end
+
+    context "really flaky" do
+      it "describes the test case 3 times" do
+        results = [fail, fail, pass]
+
+        expect(receiver).to receive(:test_case) {|test_case|
+          configuration.notify(results.shift)
+        }.exactly(3).times
+
+        filter.test_case(test_case)
+      end
+    end
+  end
+end

data/spec/cucumber/filters/tag_limits/test_case_index_spec.rb

@@ -0,0 +1,38 @@
+require "cucumber/filters/tag_limits"
+
+describe Cucumber::Filters::TagLimits::TestCaseIndex do
+  subject(:index) { Cucumber::Filters::TagLimits::TestCaseIndex.new }
+
+  let(:test_cases) do
+    [
+      double(:test_case, tags: [tag_one], location: a_location_of_tag_one),
+      double(:test_case, tags: [tag_one, tag_two], location: a_location_of_tag_one_and_tag_two)
+    ]
+  end
+
+  let(:tag_one) { double(:tag_one, name: "@one") }
+  let(:tag_two) { double(:tag_two, name: "@two") }
+
+  let(:a_location_of_tag_one) { double(:a_location_of_tag_one) }
+  let(:a_location_of_tag_one_and_tag_two) { double(:a_location_of_tag_one_and_tag_two) }
+
+  before do
+    test_cases.map do |test_case|
+      index.add(test_case)
+    end
+  end
+
+  describe "#count_by_tag_name" do
+    it "returns the number of test cases with the tag" do
+      expect(index.count_by_tag_name("@one")).to eq(2)
+      expect(index.count_by_tag_name("@two")).to eq(1)
+    end
+  end
+
+  describe "#locations_by_tag_name" do
+    it "returns the locations of test cases with the tag" do
+      expect(index.locations_of_tag_name("@one")).to eq([a_location_of_tag_one, a_location_of_tag_one_and_tag_two])
+      expect(index.locations_of_tag_name("@two")).to eq([a_location_of_tag_one_and_tag_two])
+    end
+  end
+end

data/spec/cucumber/filters/tag_limits/verifier_spec.rb

@@ -0,0 +1,57 @@
+require "cucumber/filters/tag_limits"
+
+describe Cucumber::Filters::TagLimits::Verifier do
+  describe "#verify!" do
+    subject(:verifier) { Cucumber::Filters::TagLimits::Verifier.new(tag_limits) }
+    let(:test_case_index) { double(:test_case_index) }
+
+    context "the tag counts exceed the tag limits" do
+      let(:tag_limits) do
+        {
+          "@exceed_me" => 1
+        }
+      end
+
+      let(:locations) do
+        [
+          double(:location, to_s: "path/to/some.feature:3"),
+          double(:location, to_s: "path/to/some/other.feature:8"),
+        ]
+      end
+
+      before do
+        allow(test_case_index).to receive(:count_by_tag_name).with("@exceed_me") { 2 }
+        allow(test_case_index).to receive(:locations_of_tag_name).with("@exceed_me") { locations }
+      end
+
+      it "raises a TagLimitExceeded error with the locations of the tags" do
+        expect {
+          verifier.verify!(test_case_index)
+        }.to raise_error(
+          Cucumber::Filters::TagLimitExceededError,
+          "@exceed_me occurred 2 times, but the limit was set to 1\n" +
+          "  path/to/some.feature:3\n" +
+          "  path/to/some/other.feature:8"
+        )
+      end
+    end
+
+    context "the tag counts do not exceed the tag limits" do
+      let(:tag_limits) do
+        {
+          "@dont_exceed_me" => 2
+        }
+      end
+
+      before do
+        allow(test_case_index).to receive(:count_by_tag_name).with("@dont_exceed_me") { 1 }
+      end
+
+      it "does not raise an error" do
+        expect {
+          verifier.verify!(test_case_index)
+        }.to_not raise_error
+      end
+    end
+  end
+end

data/spec/cucumber/filters/tag_limits_spec.rb

@@ -0,0 +1,59 @@
+require "cucumber/filters/tag_limits"
+
+describe Cucumber::Filters::TagLimits do
+  subject(:filter) { Cucumber::Filters::TagLimits.new(tag_limits, receiver) }
+
+  let(:tag_limits) { double(:tag_limits) }
+  let(:receiver) { double(:receiver) }
+
+  let(:gated_receiver) { double(:gated_receiver) }
+  let(:test_case_index) { double(:test_case_index) }
+  let(:test_case) { double(:test_case) }
+
+  before do
+    allow(Cucumber::Filters::GatedReceiver).to receive(:new).with(receiver) { gated_receiver }
+    allow(Cucumber::Filters::TagLimits::TestCaseIndex).to receive(:new) { test_case_index }
+  end
+
+  describe "#test_case" do
+    before do
+      allow(test_case_index).to receive(:add)
+      allow(gated_receiver).to receive(:test_case)
+    end
+
+    it "indexes the test case" do
+      expect(test_case_index).to receive(:add).with(test_case)
+      filter.test_case(test_case)
+    end
+
+    it "adds the test case to the gated receiver" do
+      expect(gated_receiver).to receive(:test_case).with(test_case)
+      filter.test_case(test_case)
+    end
+  end
+
+  describe "#done" do
+    let(:verifier) { double(:verifier) }
+
+    before do
+      allow(Cucumber::Filters::TagLimits::Verifier).to receive(:new).with(tag_limits) { verifier }
+      allow(gated_receiver).to receive(:done)
+    end
+
+    it "verifies tag limits have not been exceeded" do
+      expect(verifier).to receive(:verify!).with(test_case_index)
+      filter.done
+    end
+
+    context "the verifier verifies successfully" do
+      before do
+        allow(verifier).to receive(:verify!).with(test_case_index)
+      end
+
+      it "calls done on the receiver gate" do
+        expect(gated_receiver).to receive(:done)
+        filter.done
+      end
+    end
+  end
+end

data/spec/cucumber/formatter/ansicolor_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'cucumber/formatter/ansicolor'
+
+module Cucumber
+  module Formatter
+    describe ANSIColor do
+      include ANSIColor
+
+      it "wraps passed_param with bold green and reset to green" do
+        expect(passed_param("foo")).to eq "\e[32m\e[1mfoo\e[0m\e[0m\e[32m"
+      end
+
+      it "wraps passed in green" do
+        expect(passed("foo")).to eq "\e[32mfoo\e[0m"
+      end
+
+      it "does not reset passed if there are no arguments" do
+        expect(passed).to eq "\e[32m"
+      end
+
+      it "wraps comments in grey" do
+        expect(comment("foo")).to eq "\e[90mfoo\e[0m"
+      end
+
+      it "does not generate ansi codes when colors are disabled" do
+        ::Cucumber::Term::ANSIColor.coloring = false
+
+        expect(passed("foo")).to eq "foo"
+      end
+    end
+  end
+end