cuke_modeler 1.2.1 → 1.3.0

data/testing/rspec/spec/integration/gherkin_4_adapter_spec.rb

@@ -67,42 +67,40 @@ describe 'Gherkin4Adapter, Integration', :gherkin4 => true do
                            | param |
                            | value |
                        # final comment" }
-  let(:feature_file) { path = "#{@default_file_directory}/#{@default_feature_file_name}"
-                       File.open(path, "w") { |file| file.puts source_text }
-
-                      CukeModeler::FeatureFile.new(path) }
-  let(:feature) { feature_file.feature }
+  let(:feature_file_model) { test_file_path = CukeModeler::FileHelper.create_feature_file(:text => source_text, :name => 'adapter_test_file')
+                             CukeModeler::FeatureFile.new(test_file_path) }
+  let(:feature_model) { feature_file_model.feature }
 
 
   it "does not store parsing data for a feature file's children" do
-    model = feature_file
+    model = feature_file_model
 
     expect(model.parsing_data[:comments]).to be_nil
     expect(model.parsing_data[:feature]).to be_nil
   end
 
   it "does not store parsing data for a feature's children" do
-    model = feature
+    model = feature_model
 
     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
+    model = feature_model.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
+    model = feature_model.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
+    model = feature_model.outlines.first
 
     expect(model.parsing_data[:tags]).to be_nil
     expect(model.parsing_data[:steps]).to be_nil
@@ -110,7 +108,7 @@ describe 'Gherkin4Adapter, Integration', :gherkin4 => true do
   end
 
   it "does not store parsing data for an example's children" do
-    model = feature.outlines.first.examples.first
+    model = feature_model.outlines.first.examples.first
 
     expect(model.parsing_data[:tags]).to be_nil
     expect(model.parsing_data[:tableHeader]).to be_nil
@@ -118,31 +116,31 @@ describe 'Gherkin4Adapter, Integration', :gherkin4 => true do
   end
 
   it "does not store parsing data for an example row's children" do
-    model = feature.outlines.first.examples.first.rows.first
+    model = feature_model.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
+    model = feature_model.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
+    model = feature_model.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
+    model = feature_model.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
+    model = feature_model.outlines.first.steps.first.block.rows.first
 
     expect(model.parsing_data[:cells]).to be_nil
   end

data/testing/rspec/spec/integration/outline_integration_spec.rb

@@ -108,42 +108,44 @@ describe 'Outline, Integration' do
     describe 'getting ancestors' do
 
       before(:each) do
-        source = "#{@feature_keyword}: Test feature
+        CukeModeler::FileHelper.create_feature_file(:text => source_gherkin, :name => 'outline_test_file', :directory => test_directory)
+      end
 
-                    #{@outline_keyword}: Test test
-                      #{@step_keyword} a step
-                    #{@example_keyword}: Test example
-                      | a param |
-                      | a value |"
 
-        file_path = "#{@default_file_directory}/outline_test_file.feature"
-        File.open(file_path, 'w') { |file| file.write(source) }
-      end
+      let(:test_directory) { CukeModeler::FileHelper.create_directory }
+      let(:source_gherkin) { "#{@feature_keyword}: Test feature
+
+                              #{@outline_keyword}: Test test
+                                #{@step_keyword} a step
+                              #{@example_keyword}: Test example
+                                | a param |
+                                | a value |"
+      }
 
-      let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
-      let(:outline) { directory.feature_files.first.feature.tests.first }
+      let(:directory_model) { CukeModeler::Directory.new(test_directory) }
+      let(:outline_model) { directory_model.feature_files.first.feature.tests.first }
 
 
       it 'can get its directory' do
-        ancestor = outline.get_ancestor(:directory)
+        ancestor = outline_model.get_ancestor(:directory)
 
-        expect(ancestor).to equal(directory)
+        expect(ancestor).to equal(directory_model)
       end
 
       it 'can get its feature file' do
-        ancestor = outline.get_ancestor(:feature_file)
+        ancestor = outline_model.get_ancestor(:feature_file)
 
-        expect(ancestor).to equal(directory.feature_files.first)
+        expect(ancestor).to equal(directory_model.feature_files.first)
       end
 
       it 'can get its feature' do
-        ancestor = outline.get_ancestor(:feature)
+        ancestor = outline_model.get_ancestor(:feature)
 
-        expect(ancestor).to equal(directory.feature_files.first.feature)
+        expect(ancestor).to equal(directory_model.feature_files.first.feature)
       end
 
       it 'returns nil if it does not have the requested type of ancestor' do
-        ancestor = outline.get_ancestor(:test)
+        ancestor = outline_model.get_ancestor(:test)
 
         expect(ancestor).to be_nil
       end

data/testing/rspec/spec/integration/parsing_integration_spec.rb

@@ -46,7 +46,7 @@ describe 'Parsing, Integration' do
       expect { nodule.parse_text(:not_a_string) }.to raise_error(ArgumentError, /Symbol/)
     end
 
-    # todo - Stop doing this. Just return a feature file rooted AST.
+    # todo - Stop doing this. Just return a feature file rooted AST. (Will require major version number change)
     it 'returns an Array' do
       result = nodule.parse_text("#{@feature_keyword}:")
       expect(result).to be_a(Array)

data/testing/rspec/spec/integration/row_integration_spec.rb

@@ -83,71 +83,70 @@ describe 'Row, Integration' do
     describe 'getting ancestors' do
 
       before(:each) do
-        source = "#{@feature_keyword}: Test feature
+        CukeModeler::FileHelper.create_feature_file(:text => source_gherkin, :name => 'row_test_file', :directory => test_directory)
+      end
 
-                    #{@scenario_keyword}: Test test
-                      #{@step_keyword} a step:
-                        | a | table |"
 
-        file_path = "#{@default_file_directory}/row_test_file.feature"
-        File.open(file_path, 'w') { |file| file.write(source) }
-      end
+      let(:test_directory) { CukeModeler::FileHelper.create_directory }
+      let(:source_gherkin) { "#{@feature_keyword}: Test feature
+
+                                #{@scenario_keyword}: Test test
+                                  #{@step_keyword} a step:
+                                    | a | table |"
+      }
 
-      let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
-      let(:row) { directory.feature_files.first.feature.tests.first.steps.first.block.rows.first }
+      let(:directory_model) { CukeModeler::Directory.new(test_directory) }
+      let(:row_model) { directory_model.feature_files.first.feature.tests.first.steps.first.block.rows.first }
 
 
       it 'can get its directory' do
-        ancestor = row.get_ancestor(:directory)
+        ancestor = row_model.get_ancestor(:directory)
 
-        expect(ancestor).to equal(directory)
+        expect(ancestor).to equal(directory_model)
       end
 
       it 'can get its feature file' do
-        ancestor = row.get_ancestor(:feature_file)
+        ancestor = row_model.get_ancestor(:feature_file)
 
-        expect(ancestor).to equal(directory.feature_files.first)
+        expect(ancestor).to equal(directory_model.feature_files.first)
       end
 
       it 'can get its feature' do
-        ancestor = row.get_ancestor(:feature)
+        ancestor = row_model.get_ancestor(:feature)
 
-        expect(ancestor).to equal(directory.feature_files.first.feature)
+        expect(ancestor).to equal(directory_model.feature_files.first.feature)
       end
 
       it 'can get its step' do
-        ancestor = row.get_ancestor(:step)
+        ancestor = row_model.get_ancestor(:step)
 
-        expect(ancestor).to equal(directory.feature_files.first.feature.tests.first.steps.first)
+        expect(ancestor).to equal(directory_model.feature_files.first.feature.tests.first.steps.first)
       end
 
       it 'can get its table' do
-        ancestor = row.get_ancestor(:table)
+        ancestor = row_model.get_ancestor(:table)
 
-        expect(ancestor).to equal(directory.feature_files.first.feature.tests.first.steps.first.block)
+        expect(ancestor).to equal(directory_model.feature_files.first.feature.tests.first.steps.first.block)
       end
 
       context 'a row that is part of a scenario' do
 
-        before(:each) do
-          source = "#{@feature_keyword}: Test feature
+        let(:test_directory) { CukeModeler::FileHelper.create_directory }
+        let(:source_gherkin) { "#{@feature_keyword}: Test feature
 
-                      #{@scenario_keyword}: Test test
-                        #{@step_keyword} a step:
-                          | a | table |"
-
-          file_path = "#{@default_file_directory}/row_test_file.feature"
-          File.open(file_path, 'w') { |file| file.write(source) }
-        end
+                                  #{@scenario_keyword}: Test test
+                                    #{@step_keyword} a step:
+                                      | a | table |"
+        }
 
-        let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
-        let(:row) { directory.feature_files.first.feature.tests.first.steps.first.block.rows.first }
+        let(:directory_model) { CukeModeler::Directory.new(test_directory) }
+        let(:row_model) { directory_model.feature_files.first.feature.tests.first.steps.first.block.rows.first }
 
 
         it 'can get its scenario' do
-          ancestor = row.get_ancestor(:scenario)
+          ancestor = row_model.get_ancestor(:scenario)
 
-          expect(ancestor).to equal(directory.feature_files.first.feature.tests.first)
+          expect(ancestor).to equal(directory_model.feature_files.first.feature.tests.first)
         end
 
       end
@@ -155,64 +154,58 @@ describe 'Row, Integration' do
 
       context 'a row that is part of a background' do
 
-        before(:each) do
-          source = "#{@feature_keyword}: Test feature
+        let(:test_directory) { CukeModeler::FileHelper.create_directory }
+        let(:source_gherkin) { "#{@feature_keyword}: Test feature
 
-                      #{@background_keyword}: Test background
-                        #{@step_keyword} a step:
-                          | a | table |"
+                                #{@background_keyword}: Test background
+                                  #{@step_keyword} a step:
+                                    | a | table |"
+        }
 
-          file_path = "#{@default_file_directory}/row_test_file.feature"
-          File.open(file_path, 'w') { |file| file.write(source) }
-        end
-
-        let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
-        let(:row) { directory.feature_files.first.feature.background.steps.first.block.rows.first }
+        let(:directory_model) { CukeModeler::Directory.new(test_directory) }
+        let(:row_model) { directory_model.feature_files.first.feature.background.steps.first.block.rows.first }
 
 
         it 'can get its background' do
-          ancestor = row.get_ancestor(:background)
+          ancestor = row_model.get_ancestor(:background)
 
-          expect(ancestor).to equal(directory.feature_files.first.feature.background)
+          expect(ancestor).to equal(directory_model.feature_files.first.feature.background)
         end
 
       end
 
       context 'a row that is part of an outline' do
 
-        before(:each) do
-          source = "#{@feature_keyword}: Test feature
-                      
-                      #{@outline_keyword}: Test outline
-                        #{@step_keyword} a step
-                      #{@example_keyword}:
-                        | param |
-                        | value |"
-
-          file_path = "#{@default_file_directory}/row_test_file.feature"
-          File.open(file_path, 'w') { |file| file.write(source) }
-        end
+        let(:test_directory) { CukeModeler::FileHelper.create_directory }
+        let(:source_gherkin) { "#{@feature_keyword}: Test feature
+
+                                #{@outline_keyword}: Test outline
+                                  #{@step_keyword} a step
+                                #{@example_keyword}:
+                                  | param |
+                                  | value |"
+        }
 
-        let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
-        let(:row) { directory.feature_files.first.feature.tests.first.examples.first.rows.first }
+        let(:directory_model) { CukeModeler::Directory.new(test_directory) }
+        let(:row_model) { directory_model.feature_files.first.feature.tests.first.examples.first.rows.first }
 
 
         it 'can get its outline' do
-          ancestor = row.get_ancestor(:outline)
+          ancestor = row_model.get_ancestor(:outline)
 
-          expect(ancestor).to equal(directory.feature_files.first.feature.tests.first)
+          expect(ancestor).to equal(directory_model.feature_files.first.feature.tests.first)
         end
 
         it 'can get its example' do
-          ancestor = row.get_ancestor(:example)
+          ancestor = row_model.get_ancestor(:example)
 
-          expect(ancestor).to equal(directory.feature_files.first.feature.tests.first.examples.first)
+          expect(ancestor).to equal(directory_model.feature_files.first.feature.tests.first.examples.first)
         end
 
       end
 
       it 'returns nil if it does not have the requested type of ancestor' do
-        ancestor = row.get_ancestor(:outline)
+        ancestor = row_model.get_ancestor(:outline)
 
         expect(ancestor).to be_nil
       end

data/testing/rspec/spec/integration/scenario_integration_spec.rb

@@ -106,39 +106,41 @@ describe 'Scenario, Integration' do
     describe 'getting ancestors' do
 
       before(:each) do
-        source = "#{@feature_keyword}: Test feature
+        CukeModeler::FileHelper.create_feature_file(:text => source_gherkin, :name => 'scenario_test_file', :directory => test_directory)
+      end
 
-                    #{@scenario_keyword}: Test test
-                      #{@step_keyword} a step"
 
-        file_path = "#{@default_file_directory}/scenario_test_file.feature"
-        File.open(file_path, 'w') { |file| file.write(source) }
-      end
+      let(:test_directory) { CukeModeler::FileHelper.create_directory }
+      let(:source_gherkin) { "#{@feature_keyword}: Test feature
+
+                              #{@scenario_keyword}: Test test
+                                #{@step_keyword} a step"
+      }
 
-      let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
-      let(:scenario) { directory.feature_files.first.feature.tests.first }
+      let(:directory_model) { CukeModeler::Directory.new(test_directory) }
+      let(:scenario_model) { directory_model.feature_files.first.feature.tests.first }
 
 
       it 'can get its directory' do
-        ancestor = scenario.get_ancestor(:directory)
+        ancestor = scenario_model.get_ancestor(:directory)
 
-        expect(ancestor).to equal(directory)
+        expect(ancestor).to equal(directory_model)
       end
 
       it 'can get its feature file' do
-        ancestor = scenario.get_ancestor(:feature_file)
+        ancestor = scenario_model.get_ancestor(:feature_file)
 
-        expect(ancestor).to equal(directory.feature_files.first)
+        expect(ancestor).to equal(directory_model.feature_files.first)
       end
 
       it 'can get its feature' do
-        ancestor = scenario.get_ancestor(:feature)
+        ancestor = scenario_model.get_ancestor(:feature)
 
-        expect(ancestor).to equal(directory.feature_files.first.feature)
+        expect(ancestor).to equal(directory_model.feature_files.first.feature)
       end
 
       it 'returns nil if it does not have the requested type of ancestor' do
-        ancestor = scenario.get_ancestor(:test)
+        ancestor = scenario_model.get_ancestor(:test)
 
         expect(ancestor).to be_nil
       end

data/testing/rspec/spec/integration/step_integration_spec.rb

@@ -244,115 +244,108 @@ describe 'Step, Integration' do
     describe 'getting ancestors' do
 
       before(:each) do
-        source = "#{@feature_keyword}: Test feature
+        CukeModeler::FileHelper.create_feature_file(:text => source_gherkin, :name => 'step_test_file', :directory => test_directory)
+      end
 
-                    #{@scenario_keyword}: Test test
-                      #{@step_keyword} a step:"
 
-        file_path = "#{@default_file_directory}/step_test_file.feature"
-        File.open(file_path, 'w') { |file| file.write(source) }
-      end
+      let(:test_directory) { CukeModeler::FileHelper.create_directory }
+      let(:source_gherkin) { "#{@feature_keyword}: Test feature
 
-      let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
-      let(:step) { directory.feature_files.first.feature.tests.first.steps.first }
+                              #{@scenario_keyword}: Test test
+                                #{@step_keyword} a step:"
+      }
+
+      let(:directory_model) { CukeModeler::Directory.new(test_directory) }
+      let(:step_model) { directory_model.feature_files.first.feature.tests.first.steps.first }
 
 
       it 'can get its directory' do
-        ancestor = step.get_ancestor(:directory)
+        ancestor = step_model.get_ancestor(:directory)
 
-        expect(ancestor).to equal(directory)
+        expect(ancestor).to equal(directory_model)
       end
 
       it 'can get its feature file' do
-        ancestor = step.get_ancestor(:feature_file)
+        ancestor = step_model.get_ancestor(:feature_file)
 
-        expect(ancestor).to equal(directory.feature_files.first)
+        expect(ancestor).to equal(directory_model.feature_files.first)
       end
 
       it 'can get its feature' do
-        ancestor = step.get_ancestor(:feature)
+        ancestor = step_model.get_ancestor(:feature)
 
-        expect(ancestor).to equal(directory.feature_files.first.feature)
+        expect(ancestor).to equal(directory_model.feature_files.first.feature)
       end
 
 
       context 'a step that is part of a scenario' do
 
-        before(:each) do
-          source = "#{@feature_keyword}: Test feature
-                      
-                      #{@scenario_keyword}: Test scenario
-                        #{@step_keyword} a step"
+        let(:test_directory) { CukeModeler::FileHelper.create_directory }
+        let(:source_gherkin) { "#{@feature_keyword}: Test feature
 
-          file_path = "#{@default_file_directory}/step_test_file.feature"
-          File.open(file_path, 'w') { |file| file.write(source) }
-        end
+                                #{@scenario_keyword}: Test scenario
+                                  #{@step_keyword} a step"
+        }
 
-        let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
-        let(:step) { directory.feature_files.first.feature.tests.first.steps.first }
+        let(:directory_model) { CukeModeler::Directory.new(test_directory) }
+        let(:step_model) { directory_model.feature_files.first.feature.tests.first.steps.first }
 
 
         it 'can get its scenario' do
-          ancestor = step.get_ancestor(:scenario)
+          ancestor = step_model.get_ancestor(:scenario)
 
-          expect(ancestor).to equal(directory.feature_files.first.feature.tests.first)
+          expect(ancestor).to equal(directory_model.feature_files.first.feature.tests.first)
         end
 
       end
 
       context 'a step that is part of an outline' do
 
-        before(:each) do
-          source = "#{@feature_keyword}: Test feature
-                      
-                      #{@outline_keyword}: Test outline
-                        #{@step_keyword} a step
-                      #{@example_keyword}:
-                        | param |
-                        | value |"
-
-          file_path = "#{@default_file_directory}/step_test_file.feature"
-          File.open(file_path, 'w') { |file| file.write(source) }
-        end
+        let(:test_directory) { CukeModeler::FileHelper.create_directory }
+        let(:source_gherkin) { "#{@feature_keyword}: Test feature
+
+                                #{@outline_keyword}: Test outline
+                                  #{@step_keyword} a step
+                                #{@example_keyword}:
+                                  | param |
+                                  | value |"
+        }
 
-        let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
-        let(:step) { directory.feature_files.first.feature.tests.first.steps.first }
+        let(:directory_model) { CukeModeler::Directory.new(test_directory) }
+        let(:step_model) { directory_model.feature_files.first.feature.tests.first.steps.first }
 
 
         it 'can get its outline' do
-          ancestor = step.get_ancestor(:outline)
+          ancestor = step_model.get_ancestor(:outline)
 
-          expect(ancestor).to equal(directory.feature_files.first.feature.tests.first)
+          expect(ancestor).to equal(directory_model.feature_files.first.feature.tests.first)
         end
 
       end
 
       context 'a step that is part of a background' do
 
-        before(:each) do
-          source = "#{@feature_keyword}: Test feature
-                      
-                      #{@background_keyword}: Test background
-                        #{@step_keyword} a step"
+        let(:test_directory) { CukeModeler::FileHelper.create_directory }
+        let(:source_gherkin) { "#{@feature_keyword}: Test feature
 
-          file_path = "#{@default_file_directory}/step_test_file.feature"
-          File.open(file_path, 'w') { |file| file.write(source) }
-        end
+                                #{@background_keyword}: Test background
+                                  #{@step_keyword} a step"
+        }
 
-        let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
-        let(:step) { directory.feature_files.first.feature.background.steps.first }
+        let(:directory_model) { CukeModeler::Directory.new(test_directory) }
+        let(:step_model) { directory_model.feature_files.first.feature.background.steps.first }
 
 
         it 'can get its background' do
-          ancestor = step.get_ancestor(:background)
+          ancestor = step_model.get_ancestor(:background)
 
-          expect(ancestor).to equal(directory.feature_files.first.feature.background)
+          expect(ancestor).to equal(directory_model.feature_files.first.feature.background)
         end
 
       end
 
       it 'returns nil if it does not have the requested type of ancestor' do
-        ancestor = step.get_ancestor(:example)
+        ancestor = step_model.get_ancestor(:example)
 
         expect(ancestor).to be_nil
       end