cucumber 2.0.0.rc.4 → 4.0.0.rc.2

data/spec/cucumber/configuration_spec.rb

@@ -1,23 +0,0 @@
-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
-        expect(subject.autoload_code_paths).to include('features/support')
-        expect(subject.autoload_code_paths).to 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
-        expect(subject.autoload_code_paths).to eq ['foo/bar/baz']
-      end
-    end
-  end
-end

data/spec/cucumber/constantize_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-module Html end
-
-module Cucumber
-  describe Constantize do
-    include Constantize
-
-    it "loads html formatter" do
-      clazz = constantize('Cucumber::Formatter::Html')
-
-      expect(clazz.name).to eq 'Cucumber::Formatter::Html'
-    end
-
-    it "fails to load a made up class" do
-      expect { constantize('My::MadeUp::ClassName') }.to raise_error(LoadError)
-    end
-  end
-end

data/spec/cucumber/core_ext/proc_spec.rb

@@ -1,69 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-require 'cucumber/core_ext/proc'
-
-describe Proc do
-  it "removes extraneous path info for file" do
-    proc = lambda {|a,b|}
-
-    expect(proc.file_colon_line).to match /^spec\/cucumber\/core_ext\/proc_spec\.rb:7/
-  end
-
-  it "works with non-English path" do
-    proc = lambda {|a,b|}
-    def proc.to_s
-      "#<Proc:0x00000003c04740@#{Dir.pwd}/å/spec/cucumber/core_ext/proc_spec.rb:12 (lambda)>".force_encoding('ASCII-8BIT')
-    end
-
-    expect(proc.file_colon_line.force_encoding('UTF-8')).to match /^å\/spec\/cucumber\/core_ext\/proc_spec\.rb:12/
-  end
-
-  it "raises ArityMismatchError for too many args (expecting 0)" do
-    expect(-> {
-      Object.new.cucumber_instance_exec(true, 'foo', 1) do
-      end
-    }).to raise_error(Cucumber::ArityMismatchError, "Your block takes 0 arguments, but the Regexp matched 1 argument.")
-  end
-
-  it "raises ArityMismatchError for too many args (expecting 1)" do
-    expect(-> {
-      Object.new.cucumber_instance_exec(true, 'foo', 1,2) do |a|
-      end
-    }).to raise_error(Cucumber::ArityMismatchError, "Your block takes 1 argument, but the Regexp matched 2 arguments.")
-  end
-
-  it "raises ArityMismatchError for too few args (expecting 1)" do
-    expect(-> {
-      Object.new.cucumber_instance_exec(true, 'foo') do |a|
-      end
-    }).to raise_error(Cucumber::ArityMismatchError, "Your block takes 1 argument, but the Regexp matched 0 arguments.")
-  end
-
-  it "raises ArityMismatchError for too few args (expecting 2)" do
-    expect(-> {
-      Object.new.cucumber_instance_exec(true, 'foo', 1) do |a,b|
-      end
-    }).to raise_error(Cucumber::ArityMismatchError, "Your block takes 2 arguments, but the Regexp matched 1 argument.")
-  end
-
-  it "allows varargs (expecting 0+)" do
-    expect(-> {
-      Object.new.cucumber_instance_exec(true, 'foo', 1) do |*args|
-      end
-    }).not_to raise_error
-  end
-
-  it "allows varargs (expecting 1+)" do
-    expect(-> {
-      Object.new.cucumber_instance_exec(true, 'foo', 1) do |arg,*args|
-      end
-    }).not_to raise_error
-  end
-
-  it "raises ArityMismatchError for too few required args when using varargs (expecting 1+)" do
-    expect(-> {
-      Object.new.cucumber_instance_exec(true, nil) do |arg,*args|
-      end
-    }).to raise_error(Cucumber::ArityMismatchError, "Your block takes 1+ arguments, but the Regexp matched 0 arguments.")
-  end
-end

data/spec/cucumber/file_specs_spec.rb

@@ -1,60 +0,0 @@
-require 'cucumber/file_specs'
-
-module Cucumber
-  describe FileSpecs do
-    let(:file_specs) { FileSpecs.new(["features/foo.feature:1:2:3", "features/bar.feature:4:5:6"]) }
-    let(:locations) { file_specs.locations }
-    let(:files) { file_specs.files }
-
-    it "parses locations from multiple files" do
-      expect(locations.length).to eq 6
-      expect(locations).to eq [
-        Cucumber::Core::Ast::Location.new("features/foo.feature", 1),
-        Cucumber::Core::Ast::Location.new("features/foo.feature", 2),
-        Cucumber::Core::Ast::Location.new("features/foo.feature", 3),
-        Cucumber::Core::Ast::Location.new("features/bar.feature", 4),
-        Cucumber::Core::Ast::Location.new("features/bar.feature", 5),
-        Cucumber::Core::Ast::Location.new("features/bar.feature", 6),
-      ]
-    end
-
-    it "parses file names from multiple file specs" do
-      expect(files.length).to eq 2
-      expect(files).to eq [
-        "features/foo.feature",
-        "features/bar.feature",
-      ]
-    end
-
-    context "when files are not unique" do
-      let(:file_specs) { FileSpecs.new(["features/foo.feature:4", "features/foo.feature:34"]) }
-
-      it "parses unique file names" do
-        expect(files.length).to eq 1
-        expect(files).to eq ["features/foo.feature"]
-      end
-    end
-
-    context "when no line number is specified" do
-      let(:file_specs) { FileSpecs.new(["features/foo.feature", "features/bar.feature:34"]) }
-
-      it "returns a wildcard location for that file" do
-        expect(locations).to eq [
-          Cucumber::Core::Ast::Location.new("features/foo.feature"),
-          Cucumber::Core::Ast::Location.new("features/bar.feature", 34),
-        ]
-      end
-    end
-
-    context "when the same file is referenced more than once" do
-      let(:file_specs) { FileSpecs.new(["features/foo.feature:10", "features/foo.feature:1"]) }
-
-      it "returns locations in the order specified" do
-        expect(locations).to eq [
-          Cucumber::Core::Ast::Location.new("features/foo.feature", 10),
-          Cucumber::Core::Ast::Location.new("features/foo.feature", 1),
-        ]
-      end
-    end
-  end
-end

data/spec/cucumber/filters/activate_steps_spec.rb

@@ -1,57 +0,0 @@
-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_definitions) { double(find_match: step_match) }
-  let(:step_match) { double(activate: activated_test_step) }
-  let(:activated_test_step) { double }
-  let(:receiver) { double.as_null_object }
-
-  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, [Cucumber::Filters::ActivateSteps.new(step_definitions)]
-    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, [Cucumber::Filters::ActivateSteps.new(step_definitions)]
-    end
-  end
-
-end

data/spec/cucumber/filters/gated_receiver_spec.rb

@@ -1,47 +0,0 @@
-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/tag_limits/test_case_index_spec.rb

@@ -1,38 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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