cucumber-core 0.1.0

data/spec/cucumber/core/ast/location_spec.rb

@@ -0,0 +1,105 @@
+require 'cucumber/core/ast/location'
+
+module Cucumber::Core::Ast
+  describe Location do
+    let(:line) { 12 }
+    let(:file) { "foo.feature" }
+
+    describe "equality" do
+      it "is equal to another Location on the same line of the same file" do
+        one_location = Location.new(file, line)
+        another_location = Location.new(file, line)
+        expect( one_location ).to eq another_location
+      end
+
+       it "is not equal to a wild card of the same file" do
+         expect( Location.new(file, line) ).not_to eq Location.new(file)
+       end
+    end
+
+    describe "to_s" do
+      it "is file:line for a precise location" do
+        expect( Location.new("foo.feature", 12).to_s ).to eq "foo.feature:12"
+      end
+
+      it "is file for a wildcard location" do
+        expect( Location.new("foo.feature").to_s ).to eq "foo.feature"
+      end
+
+      it "is file:first_line..last_line for a ranged location" do
+        expect( Location.new("foo.feature", 13..19).to_s ).to eq "foo.feature:13..19"
+      end
+    end
+
+    describe "matches" do
+      let(:matching) { Location.new(file, line) }
+      let(:same_file_other_line) { Location.new(file, double) }
+      let(:not_matching) { Location.new(other_file, line) }
+      let(:other_file) { double }
+
+      context 'a precise location' do
+        let(:precise) { Location.new(file, line) }
+
+        it "matches a precise location of the same file and line" do
+          expect( matching ).to be_match(precise)
+        end
+
+        it "does not match a precise location on a differnt line in the same file" do
+          expect( matching ).not_to be_match(same_file_other_line)
+        end
+
+      end
+
+      context 'a wildcard' do
+        let(:wildcard) { Location.new(file) }
+
+        it "matches any location with the same filename" do
+          expect( wildcard ).to be_match(matching)
+        end
+
+        it "is matched by any location of the same file" do
+          expect( matching ).to be_match(wildcard)
+        end
+
+        it "does not match a location in a different file" do
+          expect( wildcard ).not_to be_match(not_matching)
+        end
+      end
+
+      context 'a range wildcard' do
+        let(:range) { Location.new("foo.feature", 13..17) }
+        
+        it "matches the first line in the same file" do
+          other = Location.new("foo.feature", 13)
+          expect( range ).to be_match(other)
+        end
+
+        it "matches a line within the docstring in the same file" do
+          other = Location.new("foo.feature", 15)
+          expect( range ).to be_match(other)
+        end
+
+        it "is matched by a line within the docstring in the same file" do
+          other = Location.new("foo.feature", 15)
+          expect( other ).to be_match(range)
+        end
+
+        it "matches a wildcard in the same file" do
+          wildcard = Location.new("foo.feature")
+          expect( range ).to be_match(wildcard)
+        end
+
+        it "does not match a location outside of the range" do
+          other = Location.new("foo.feature", 18)
+          expect( range ).not_to be_match(other)
+        end
+
+        it "does not match a location in another file" do
+          other = Location.new("bar.feature", 13)
+          expect( range ).not_to be_match(other)
+        end
+      end
+    end
+  end
+end
+

data/spec/cucumber/core/ast/outline_step_spec.rb

@@ -0,0 +1,77 @@
+require 'cucumber/core/ast/outline_step'
+require 'cucumber/core/ast/examples_table'
+require 'cucumber/core/ast/data_table'
+require 'cucumber/core/ast/doc_string'
+
+module Cucumber
+  module Core
+    module Ast
+      describe OutlineStep do
+        let(:outline_step) { OutlineStep.new(language, location, keyword, name) }
+        let(:language) { double }
+        let(:location) { double }
+        let(:keyword)  { double }
+        let(:name)     { 'anything' }
+
+        describe 'location' do
+          it "has a location" do
+            expect( outline_step ).to respond_to(:location)
+          end
+
+          it 'knows the file and line' do
+            location.stub(:to_s) { 'file_name:8' }
+            expect( outline_step.file_colon_line ).to eq 'file_name:8'
+          end
+        end
+
+        describe "converting to a Step" do
+          context "a single argument in the name" do
+            let(:name) { 'a <color> cucumber' }
+
+            it "replaces the argument" do
+              row = ExamplesTable::Row.new({'color' => 'green'}, 1, location)
+              expect( outline_step.to_step(row).name ).to eq 'a green cucumber'
+            end
+
+          end
+
+          context "when the step has a DataTable" do
+            let(:outline_step) { OutlineStep.new(language, location, keyword, name, table) }
+            let(:name)  { "anything" }
+            let(:table) { DataTable.new([['x', 'y'],['a', 'a <arg>']], Location.new('foo.feature', 23)) }
+
+            it "replaces the arguments in the DataTable" do
+              visitor = double
+              visitor.stub(:step).and_yield
+              expect( visitor ).to receive(:table) do |data_table| # TODO: rename this message to :data_table
+                expect( data_table.raw ).to eq [['x', 'y'], ['a', 'a replacement']]
+              end
+              row = ExamplesTable::Row.new({'arg' => 'replacement'}, 1, location)
+              step = outline_step.to_step(row)
+              step.describe_to(visitor)
+            end
+          end
+
+          context "when the step has a DocString" do
+            let(:location) { double }
+            let(:outline_step) { OutlineStep.new(language, location, keyword, name, doc_string) }
+            let(:doc_string) { DocString.new('a <arg> that needs replacing', '', location) }
+            let(:name) { 'anything' }
+
+            it "replaces the arguments in the DocString" do
+              visitor = double
+              visitor.stub(:step).and_yield
+              expect( visitor ).to receive(:doc_string) do |doc_string|
+                expect( doc_string.content ).to eq "a replacement that needs replacing"
+              end
+              row = ExamplesTable::Row.new({'arg' => 'replacement'}, 1, location)
+              step = outline_step.to_step(row)
+              step.describe_to(visitor)
+            end
+          end
+        end
+      end
+    end
+  end
+end
+

data/spec/cucumber/core/ast/step_spec.rb

@@ -0,0 +1,44 @@
+require 'cucumber/core/ast/step'
+
+module Cucumber
+  module Core
+    module Ast
+      describe Step do
+        let(:step) do
+          language, location, keyword, name = double, double, double, double
+          Step.new(language, location, keyword, name)
+        end
+
+        describe "describing itself" do
+          let(:visitor) { double }
+
+          it "describes itself as a step" do
+            expect( visitor ).to receive(:step).with(step)
+            step.describe_to(visitor)
+          end
+
+          context "with no multiline argument" do
+            it "does not try to describe any children" do
+              visitor.stub(:step).with(step).and_yield
+              step.describe_to(visitor)
+            end
+          end
+
+          context "with a multiline argument" do
+            let(:step) { Step.new(double, double, double, double, multiline_arg) }
+            let(:multiline_arg) { double }
+
+            it "tells its multiline argument to describe itself" do
+              visitor.stub(:step).with(step).and_yield
+              expect( multiline_arg ).to receive(:describe_to).with(visitor)
+              step.describe_to(visitor)
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end
+

data/spec/cucumber/core/compiler_spec.rb

@@ -0,0 +1,249 @@
+require 'cucumber/core'
+require 'cucumber/core/compiler'
+require 'cucumber/core/gherkin/writer'
+
+module Cucumber::Core
+  describe Compiler do
+    include Gherkin::Writer
+    include Cucumber::Core
+
+    def self.stubs(*names)
+      names.each do |name|
+        let(name) { double(name.to_s) }
+      end
+    end
+
+    it "compiles a feature with a single scenario" do
+      gherkin_documents = [
+        gherkin do
+          feature do
+            scenario do
+              step 'passing'
+            end
+          end
+        end
+      ]
+      compile(gherkin_documents) do |visitor|
+        expect( visitor ).to receive(:test_case).once.ordered.and_yield
+        expect( visitor ).to receive(:test_step).once.ordered
+        expect( visitor ).to receive(:done).once.ordered
+      end
+    end
+
+    it "compiles a feature with a background" do
+      gherkin_documents = [
+        gherkin do
+          feature do
+            background do
+              step 'passing'
+            end
+
+            scenario do
+              step 'passing'
+            end
+          end
+        end
+      ]
+      compile(gherkin_documents) do |visitor|
+        expect( visitor ).to receive(:test_case).once.ordered.and_yield
+        expect( visitor ).to receive(:test_step).exactly(2).times.ordered
+        expect( visitor ).to receive(:done).once.ordered
+      end
+    end
+
+    it "compiles multiple features" do
+      gherkin_documents = [
+        gherkin do
+          feature do
+            background do
+              step 'passing'
+            end
+            scenario do
+              step 'passing'
+            end
+          end
+        end,
+        gherkin do
+          feature do
+            background do
+              step 'passing'
+            end
+            scenario do
+              step 'passing'
+            end
+          end
+        end
+      ]
+      compile(gherkin_documents) do |visitor|
+        expect( visitor ).to receive(:test_case).once.ordered
+        expect( visitor ).to receive(:test_step).twice.ordered
+        expect( visitor ).to receive(:test_case).once.ordered
+        expect( visitor ).to receive(:test_step).twice.ordered
+        expect( visitor ).to receive(:done).once
+      end
+    end
+
+    context "compiling scenario outlines" do
+      it "compiles a scenario outline to test cases" do
+        gherkin_documents = [
+          gherkin do
+            feature do
+              background do
+                step 'passing'
+              end
+
+              scenario_outline do
+                step 'passing <arg>'
+                step 'passing'
+
+                examples 'examples 1' do
+                  row 'arg'
+                  row '1'
+                  row '2'
+                end
+
+                examples 'examples 2' do
+                  row 'arg'
+                  row 'a'
+                end
+              end
+            end
+          end
+        ]
+        compile(gherkin_documents) do |visitor|
+          expect( visitor ).to receive(:test_case).exactly(3).times.and_yield
+          expect( visitor ).to receive(:test_step).exactly(9).times
+          expect( visitor ).to receive(:done).once
+        end
+      end
+
+      it 'replaces arguments correctly when generating test steps' do
+        gherkin_documents = [
+          gherkin do
+            feature do
+              scenario_outline do
+                step 'passing <arg1> with <arg2>'
+                step 'as well as <arg3>'
+
+                examples do
+                  row 'arg1', 'arg2', 'arg3'
+                  row '1',    '2',    '3'
+                end
+              end
+            end
+          end
+        ]
+
+        compile(gherkin_documents) do |visitor|
+          expect( visitor ).to receive(:test_step) do |test_step|
+            visit_source(test_step) do |source_visitor|
+              expect( source_visitor ).to receive(:step) do |step|
+                expect(step.name).to eq 'passing 1 with 2'
+              end
+            end
+          end.once.ordered
+
+          expect( visitor ).to receive(:test_step) do |test_step|
+            visit_source(test_step) do |source_visitor|
+              expect( source_visitor ).to receive(:step) do |step|
+                expect(step.name).to eq 'as well as 3'
+              end
+            end
+          end.once.ordered
+
+          expect( visitor ).to receive(:done).once.ordered
+        end
+      end
+    end
+
+    describe Compiler::FeatureCompiler do
+      let(:receiver) { double('receiver') }
+      let(:compiler) { Compiler::FeatureCompiler.new(receiver) }
+
+      context "a scenario with a background" do
+        stubs(:feature,
+                :background,
+                  :background_step,
+                :scenario,
+                  :scenario_step)
+
+        it "sets the source correctly on the test steps" do
+          expect( receiver ).to receive(:on_background_step).with(
+            [feature, background, background_step]
+          )
+          expect( receiver ).to receive(:on_step).with(
+            [feature, scenario, scenario_step]
+          )
+          expect( receiver ).to receive(:on_test_case).with(
+            [feature, scenario]
+          )
+          compiler.feature(feature) do |f|
+            f.background(background) do |b|
+              b.step background_step
+            end
+            f.scenario(scenario) do |s|
+              s.step scenario_step
+            end
+          end
+        end
+      end
+
+      context "a scenario outline" do
+        stubs(:feature,
+                :background,
+                  :background_step,
+                :scenario_outline,
+                  :outline_step,
+                  :examples_table_1,
+                    :examples_table_1_row_1,
+                      :outline_ast_step,
+                  :examples_table_2,
+                    :examples_table_2_row_1,
+             )
+
+        it "sets the source correctly on the test steps" do
+          outline_step.stub(to_step: outline_ast_step)
+          expect( receiver ).to receive(:on_step).with(
+            [feature, scenario_outline, examples_table_1, examples_table_1_row_1, outline_ast_step]
+          ).ordered
+          expect( receiver ).to receive(:on_test_case).with(
+            [feature, scenario_outline, examples_table_1, examples_table_1_row_1]
+          ).ordered
+          expect( receiver ).to receive(:on_step).with(
+            [feature, scenario_outline, examples_table_2, examples_table_2_row_1, outline_ast_step]
+          ).ordered
+          expect( receiver ).to receive(:on_test_case).with(
+            [feature, scenario_outline, examples_table_2, examples_table_2_row_1]
+          ).ordered
+          compiler.feature(feature) do |f|
+            f.scenario_outline(scenario_outline) do |o|
+              o.outline_step outline_step
+              o.examples_table(examples_table_1) do |t|
+                t.examples_table_row(examples_table_1_row_1)
+              end
+              o.examples_table(examples_table_2) do |t|
+                t.examples_table_row(examples_table_2_row_1)
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def visit_source(node)
+      visitor = double.as_null_object
+      yield visitor
+      node.describe_source_to(visitor)
+    end
+
+    def compile(gherkin_documents)
+      visitor = double
+      visitor.stub(:test_suite).and_yield
+      visitor.stub(:test_case).and_yield
+      yield visitor
+      super(gherkin_documents, visitor)
+    end
+
+  end
+end
+