cuke_modeler 0.4.1 → 1.0.0

data/spec/integration/gherkin_2_adapter_spec.rb

@@ -0,0 +1,122 @@
+require 'spec_helper'
+
+
+describe 'Gherkin2Adapter, Integration', :gherkin2 => true do
+
+  let(:source_text) { '@tag1 @tag2 @tag3
+                       Feature: A feature with everything it could have
+
+                       Including a description
+                       and then some.
+
+                         Background:
+
+                         Background
+                         description
+
+                           * a step
+                             | value1 |
+                           * another step
+
+                         @scenario_tag
+                         Scenario:
+
+                         Scenario
+                         description
+
+                           * a step
+                           * another step
+                             """"
+                             some text
+                             """
+
+                         @outline_tag
+                         Scenario Outline:
+
+                         Outline
+                         description
+
+                           * a step
+                             | value2 |
+                           * another step
+                             """
+                             some text
+                             """
+
+                         @example_tag
+                         Examples:
+
+                         Example
+                         description
+
+                           | param |
+                           | value |' }
+  let(:feature) { CukeModeler::Feature.new(source_text) }
+
+
+  it "does not store parsing data for a feature's children" do
+    model = feature
+
+    expect(model.parsing_data['tags']).to be_nil
+    expect(model.parsing_data['elements']).to be_nil
+  end
+
+  it "does not store parsing data for a background's children" do
+    model = feature.background
+
+    expect(model.parsing_data['steps']).to be_nil
+  end
+
+  it "does not store parsing data for a scenario's children" do
+    model = feature.scenarios.first
+
+    expect(model.parsing_data['tags']).to be_nil
+    expect(model.parsing_data['steps']).to be_nil
+  end
+
+  it "does not store parsing data for an outline's children" do
+    model = feature.outlines.first
+
+    expect(model.parsing_data['tags']).to be_nil
+    expect(model.parsing_data['steps']).to be_nil
+    expect(model.parsing_data['examples']).to be_nil
+  end
+
+  it "does not store parsing data for an example's children" do
+    model = feature.outlines.first.examples.first
+
+    expect(model.parsing_data['tags']).to be_nil
+    expect(model.parsing_data['rows']).to be_nil
+  end
+
+  it "does not store parsing data for an example row's children" do
+    model = feature.outlines.first.examples.first.rows.first
+
+    expect(model.parsing_data['cells']).to be_nil
+  end
+
+  it "does not store parsing data for a step's children, table" do
+    model = feature.outlines.first.steps.first
+
+    expect(model.parsing_data['rows']).to be_nil
+  end
+
+  it "does not store parsing data for a step's children, doc string" do
+    model = feature.outlines.first.steps.last
+
+    expect(model.parsing_data['doc_string']).to be_nil
+  end
+
+  it "does not store parsing data for a table's children" do
+    model = feature.outlines.first.steps.first.block
+
+    expect(model.parsing_data).to be_empty
+  end
+
+  it "does not store parsing data for a table row's children" do
+    model = feature.outlines.first.steps.first.block.rows.first
+
+    expect(model.parsing_data['cells']).to be_nil
+  end
+
+end

data/spec/integration/gherkin_3_adapter_spec.rb

@@ -0,0 +1,125 @@
+require 'spec_helper'
+
+
+describe 'Gherkin3Adapter, Integration', :gherkin3 => true do
+
+  let(:source_text) { '@tag1 @tag2 @tag3
+                       Feature: A feature with everything it could have
+
+                       Including a description
+                       and then some.
+
+                         Background:
+
+                         Background
+                         description
+
+                           * a step
+                             | value1 |
+                           * another step
+
+                         @scenario_tag
+                         Scenario:
+
+                         Scenario
+                         description
+
+                           * a step
+                           * another step
+                             """"
+                             some text
+                             """
+
+                         @outline_tag
+                         Scenario Outline:
+
+                         Outline
+                         description
+
+                           * a step
+                             | value2 |
+                           * another step
+                             """
+                             some text
+                             """
+
+                         @example_tag
+                         Examples:
+
+                         Example
+                         description
+
+                           | param |
+                           | value |' }
+  let(:feature) { CukeModeler::Feature.new(source_text) }
+
+
+  it "does not store parsing data for a feature's children" do
+    model = feature
+
+    expect(model.parsing_data[:tags]).to be_nil
+    expect(model.parsing_data[:scenarioDefinitions]).to be_nil
+    expect(model.parsing_data[:background]).to be_nil
+  end
+
+  it "does not store parsing data for a background's children" do
+    model = feature.background
+
+    expect(model.parsing_data[:steps]).to be_nil
+  end
+
+  it "does not store parsing data for a scenario's children" do
+    model = feature.scenarios.first
+
+    expect(model.parsing_data[:tags]).to be_nil
+    expect(model.parsing_data[:steps]).to be_nil
+  end
+
+  it "does not store parsing data for an outline's children" do
+    model = feature.outlines.first
+
+    expect(model.parsing_data[:tags]).to be_nil
+    expect(model.parsing_data[:steps]).to be_nil
+    expect(model.parsing_data[:examples]).to be_nil
+  end
+
+  it "does not store parsing data for an example's children" do
+    model = feature.outlines.first.examples.first
+
+    expect(model.parsing_data[:tags]).to be_nil
+    expect(model.parsing_data[:tableHeader]).to be_nil
+    expect(model.parsing_data[:tableBody]).to be_nil
+  end
+
+  it "does not store parsing data for an example row's children" do
+    model = feature.outlines.first.examples.first.rows.first
+
+    expect(model.parsing_data[:cells]).to be_nil
+  end
+
+  it "does not store parsing data for a step's children, table" do
+    model = feature.outlines.first.steps.first
+
+    expect(model.parsing_data[:argument]).to be_nil
+  end
+
+  it "does not store parsing data for a step's children, doc string" do
+    model = feature.outlines.first.steps.last
+
+    expect(model.parsing_data[:argument]).to be_nil
+  end
+
+  it "does not store parsing data for a table's children" do
+    model = feature.outlines.first.steps.first.block
+
+    expect(model.parsing_data[:rows]).to be_nil
+  end
+
+  it "does not store parsing data for a table row's children" do
+    model = feature.outlines.first.steps.first.block.rows.first
+
+    expect(model.parsing_data[:cells]).to be_nil
+  end
+
+
+end

data/spec/integration/gherkin_4_adapter_spec.rb

@@ -0,0 +1,123 @@
+require 'spec_helper'
+
+
+describe 'Gherkin4Adapter, Integration', :gherkin4 => true do
+
+  let(:source_text) { '@tag1 @tag2 @tag3
+                       Feature: A feature with everything it could have
+
+                       Including a description
+                       and then some.
+
+                         Background:
+
+                         Background
+                         description
+
+                           * a step
+                             | value1 |
+                           * another step
+
+                         @scenario_tag
+                         Scenario:
+
+                         Scenario
+                         description
+
+                           * a step
+                           * another step
+                             """"
+                             some text
+                             """
+
+                         @outline_tag
+                         Scenario Outline:
+
+                         Outline
+                         description
+
+                           * a step
+                             | value2 |
+                           * another step
+                             """
+                             some text
+                             """
+
+                         @example_tag
+                         Examples:
+
+                         Example
+                         description
+
+                           | param |
+                           | value |' }
+  let(:feature) { CukeModeler::Feature.new(source_text) }
+
+
+  it "does not store parsing data for a feature's children" do
+    model = feature
+
+    expect(model.parsing_data[:tags]).to be_nil
+    expect(model.parsing_data[:children]).to be_nil
+  end
+
+  it "does not store parsing data for a background's children" do
+    model = feature.background
+
+    expect(model.parsing_data[:steps]).to be_nil
+  end
+
+  it "does not store parsing data for a scenario's children" do
+    model = feature.scenarios.first
+
+    expect(model.parsing_data[:tags]).to be_nil
+    expect(model.parsing_data[:steps]).to be_nil
+  end
+
+  it "does not store parsing data for an outline's children" do
+    model = feature.outlines.first
+
+    expect(model.parsing_data[:tags]).to be_nil
+    expect(model.parsing_data[:steps]).to be_nil
+    expect(model.parsing_data[:examples]).to be_nil
+  end
+
+  it "does not store parsing data for an example's children" do
+    model = feature.outlines.first.examples.first
+
+    expect(model.parsing_data[:tags]).to be_nil
+    expect(model.parsing_data[:tableHeader]).to be_nil
+    expect(model.parsing_data[:tableBody]).to be_nil
+  end
+
+  it "does not store parsing data for an example row's children" do
+    model = feature.outlines.first.examples.first.rows.first
+
+    expect(model.parsing_data[:cells]).to be_nil
+  end
+
+  it "does not store parsing data for a step's children, table" do
+    model = feature.outlines.first.steps.first
+
+    expect(model.parsing_data[:argument]).to be_nil
+  end
+
+  it "does not store parsing data for a step's children, doc string" do
+    model = feature.outlines.first.steps.last
+
+    expect(model.parsing_data[:argument]).to be_nil
+  end
+
+  it "does not store parsing data for a table's children" do
+    model = feature.outlines.first.steps.first.block
+
+    expect(model.parsing_data[:rows]).to be_nil
+  end
+
+  it "does not store parsing data for a table row's children" do
+    model = feature.outlines.first.steps.first.block.rows.first
+
+    expect(model.parsing_data[:cells]).to be_nil
+  end
+
+end

data/spec/integration/model_integration_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+
+describe 'Model, Integration' do
+
+  let(:clazz) { CukeModeler::Model }
+
+
+  describe 'common behavior' do
+
+    it_should_behave_like 'a model, integration'
+
+  end
+
+end

data/spec/integration/nested_integration_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+
+describe 'Nested, Integration' do
+
+  let(:nodule) { CukeModeler::Nested }
+  let(:nested_model) { Object.new.extend(nodule) }
+
+
+  describe 'unique behavior' do
+
+    describe 'an object including the module' do
+
+      describe 'getting ancestors' do
+
+        context 'with a background ancestor' do
+
+          let(:background) { CukeModeler::Background.new }
+
+          before(:each) do
+            nested_model.parent_model = background
+          end
+
+
+          it "will find its background as a 'test' ancestor" do
+            ancestor = nested_model.get_ancestor(:test)
+
+            expect(ancestor).to equal(background)
+          end
+
+          it "will find its background as a 'background' ancestor" do
+            ancestor = nested_model.get_ancestor(:background)
+
+            expect(ancestor).to equal(background)
+          end
+
+        end
+
+        context 'with a scenario ancestor' do
+
+          let(:scenario) { CukeModeler::Scenario.new }
+
+          before(:each) do
+            nested_model.parent_model = scenario
+          end
+
+
+          it "will find its scenario as a 'test' ancestor" do
+            ancestor = nested_model.get_ancestor(:test)
+
+            expect(ancestor).to equal(scenario)
+          end
+
+          it "will find its scenario as a 'scenario' ancestor" do
+            ancestor = nested_model.get_ancestor(:scenario)
+
+            expect(ancestor).to equal(scenario)
+          end
+
+        end
+
+        context 'with an outline ancestor' do
+
+          let(:outline) { CukeModeler::Outline.new }
+
+          before(:each) do
+            nested_model.parent_model = outline
+          end
+
+
+          it "will find its outline as a 'test' ancestor" do
+            ancestor = nested_model.get_ancestor(:test)
+
+            expect(ancestor).to equal(outline)
+          end
+
+          it "will find its outline as a 'outline' ancestor" do
+            ancestor = nested_model.get_ancestor(:outline)
+
+            expect(ancestor).to equal(outline)
+          end
+
+        end
+
+      end
+
+    end
+
+  end
+
+end