cuke_modeler 1.2.1 → 1.3.0

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

@@ -71,31 +71,33 @@ describe 'Comment, Integration' do
     describe 'getting ancestors' do
 
       before(:each) do
-        source = "# feature comment
-                  #{@feature_keyword}: Test feature"
-
-        file_path = "#{@default_file_directory}/comment_test_file.feature"
-        File.open(file_path, 'w') { |file| file.write(source) }
+        CukeModeler::FileHelper.create_feature_file(:text => source_gherkin, :name => 'comment_test_file', :directory => test_directory)
       end
 
-      let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
-      let(:comment) { directory.feature_files.first.comments.first }
+
+      let(:test_directory) { CukeModeler::FileHelper.create_directory }
+      let(:source_gherkin) { "# feature comment
+                              #{@feature_keyword}: Test feature"
+      }
+
+      let(:directory_model) { CukeModeler::Directory.new(test_directory) }
+      let(:comment_model) { directory_model.feature_files.first.comments.first }
 
 
       it 'can get its directory' do
-        ancestor = comment.get_ancestor(:directory)
+        ancestor = comment_model.get_ancestor(:directory)
 
-        expect(ancestor).to equal(directory)
+        expect(ancestor).to equal(directory_model)
       end
 
       it 'can get its feature file' do
-        ancestor = comment.get_ancestor(:feature_file)
+        ancestor = comment_model.get_ancestor(:feature_file)
 
-        expect(ancestor).to equal(directory.feature_files.first)
+        expect(ancestor).to equal(directory_model.feature_files.first)
       end
 
       it 'returns nil if it does not have the requested type of ancestor' do
-        ancestor = comment.get_ancestor(:example)
+        ancestor = comment_model.get_ancestor(:example)
 
         expect(ancestor).to be_nil
       end
@@ -116,12 +118,11 @@ describe 'Comment, Integration' do
         end
 
         it "models the comment's source line" do
-          path = "#{@default_file_directory}/#{@default_feature_file_name}"
           source_text = "# a comment
                          #{@feature_keyword}:"
 
-          File.open(path, "w") { |file| file.puts source_text }
-          comment = CukeModeler::FeatureFile.new(path).comments.first
+          test_file_path = CukeModeler::FileHelper.create_feature_file(:text => source_text, :name => 'comment_test_file')
+          comment = CukeModeler::FeatureFile.new(test_file_path).comments.first
 
           expect(comment.source_line).to eq(1)
         end

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

@@ -21,52 +21,48 @@ describe 'Directory, Integration' do
 
       context 'with an existing directory' do
 
-        let(:directory_path) { "#{@default_file_directory}/test_directory" }
-        let(:directory) { clazz.new(directory_path) }
+        let(:root_test_path) { CukeModeler::FileHelper.create_directory }
 
-        before(:each) do
-          FileUtils.mkdir(directory_path)
-        end
+        let(:directory_path) { CukeModeler::FileHelper.create_directory(:name => 'nested_directory', :directory => root_test_path) }
+        let(:directory_model) { clazz.new(directory_path) }
 
 
         it 'models the path of the directory' do
-          expect(directory.path).to eq(directory_path)
+          expect(directory_model.path).to eq(directory_path)
         end
 
         it 'models the name of the directory' do
           name = File.basename(directory_path)
 
-          expect(directory.name).to eq(name)
+          expect(directory_model.name).to eq(name)
         end
 
 
         context 'with both files and feature files' do
 
-          let(:feature_files) { ['test_file_1.feature', 'test_file_2.feature'] }
-          let(:non_feature_files) { ['random.file'] }
+          let(:feature_files) { ['test_file_1', 'test_file_2'] }
+          let(:non_feature_files) { ['test_file_3'] }
 
           before(:each) do
             feature_files.each do |file_name|
               # Some versions of Gherkin require feature content to be present in feature files
-              File.open("#{directory_path}/#{file_name}", "w") { |file|
-                file.puts("#{@feature_keyword}: Test feature")
-              }
+              CukeModeler::FileHelper.create_feature_file(:text => "#{@feature_keyword}: Test feature", :name => file_name, :directory => directory_path)
             end
 
             non_feature_files.each do |file_name|
-              FileUtils.touch("#{directory_path}/#{file_name}")
+              CukeModeler::FileHelper.create_file(:text => '', :name => file_name, :extension => '.file', :directory => directory_path)
             end
           end
 
 
           it 'models the feature files contained in the directory' do
-            modeled_files = directory.feature_files.collect { |file| file.name }
+            modeled_files = directory_model.feature_files.collect { |file| file.name[/test_file_\d/] }
 
             expect(modeled_files).to match_array(feature_files)
           end
 
           it 'does not model non-feature files contained in the directory' do
-            modeled_files = directory.feature_files.collect { |file| file.name }
+            modeled_files = directory_model.feature_files.collect { |file| file.name[/test_file_\d/] }
 
             non_feature_files.all? do |file|
               expect(modeled_files).to_not include(file)
@@ -78,13 +74,12 @@ describe 'Directory, Integration' do
 
         context 'with no feature files' do
 
-          before(:each) do
-            FileUtils.rm(Dir.glob("#{directory_path}/#{@step_keyword}"))
-          end
+          let(:directory_path) { CukeModeler::FileHelper.create_directory(:name => 'empty_directory', :directory => root_test_path) }
+          let(:directory_model) { clazz.new(directory_path) }
 
 
           it 'models the feature files contained in the directory' do
-            modeled_files = directory.feature_files.collect { |file| file.name }
+            modeled_files = directory_model.feature_files.collect { |file| file.name }
 
             expect(modeled_files).to eq([])
           end
@@ -94,16 +89,20 @@ describe 'Directory, Integration' do
 
         context 'with a nested directory' do
 
+          let(:directory_path) { CukeModeler::FileHelper.create_directory(:name => 'test_directory', :directory => root_test_path) }
+          let(:directory_model) { clazz.new(directory_path) }
+
           let(:nested_directories) { ['nested_directory_1', 'nested_directory_2'] }
 
           before(:each) do
             nested_directories.each do |nested_directory|
-              FileUtils.mkdir("#{directory_path}/#{nested_directory}")
+              CukeModeler::FileHelper.create_directory(:name => nested_directory, :directory => directory_path)
             end
           end
 
+
           it 'models the directories in the directory' do
-            modeled_directories = directory.directories.collect { |nested_directory| nested_directory.name }
+            modeled_directories = directory_model.directories.collect { |nested_directory| nested_directory.name[/nested_directory_\d/] }
 
             expect(modeled_directories).to match_array(nested_directories)
           end
@@ -113,13 +112,12 @@ describe 'Directory, Integration' do
 
         context 'with no directories' do
 
-          before(:each) do
-            FileUtils.rm_r(Dir.glob("#{directory_path}/#{@step_keyword}"))
-          end
+          let(:directory_path) { CukeModeler::FileHelper.create_directory(:name => 'empty_directory', :directory => root_test_path) }
+          let(:directory_model) { clazz.new(directory_path) }
 
 
           it 'models the directories contained in the directory' do
-            modeled_directories = directory.directories.collect { |nested_directory| nested_directory.name }
+            modeled_directories = directory_model.directories.collect { |nested_directory| nested_directory.name }
 
             expect(modeled_directories).to eq([])
           end
@@ -131,11 +129,8 @@ describe 'Directory, Integration' do
 
       context 'with a non-existing directory' do
 
-        let(:directory_path) { "#{@default_file_directory}/test_directory" }
-
-        before(:each) do
-          FileUtils.remove_dir(directory_path, true)
-        end
+        let(:root_test_path) { CukeModeler::FileHelper.create_directory }
+        let(:directory_path) { "#{root_test_path}/this_directory_should_not_exist" }
 
 
         it 'cannot model a non-existent directory' do
@@ -148,41 +143,41 @@ describe 'Directory, Integration' do
 
 
     it 'properly sets its child models' do
-      nested_directory = "#{@default_file_directory}/nested_directory"
-      file_path = "#{@default_file_directory}/#{@default_feature_file_name}"
+      directory_path = CukeModeler::FileHelper.create_directory
+      _nested_directory_path = CukeModeler::FileHelper.create_directory(:name => 'nested_directory', :directory => directory_path)
+
+      CukeModeler::FileHelper.create_feature_file(:text => "#{@feature_keyword}: Test feature", :name => 'test_file', :directory => directory_path)
 
-      FileUtils.mkdir(nested_directory)
-      File.open(file_path, "w") { |file|
-        file.puts("#{@feature_keyword}: Test feature")
-      }
 
-      directory = clazz.new(@default_file_directory)
-      nested_directory = directory.directories.first
-      file = directory.feature_files.first
+      directory_model = clazz.new(directory_path)
+      nested_directory_model = directory_model.directories.first
+      file_model = directory_model.feature_files.first
 
-      expect(nested_directory.parent_model).to equal(directory)
-      expect(file.parent_model).to equal(directory)
+      expect(nested_directory_model.parent_model).to equal(directory_model)
+      expect(file_model.parent_model).to equal(directory_model)
     end
 
 
     describe 'getting ancestors' do
 
       before(:each) do
-        FileUtils.mkdir("#{@default_file_directory}/nested_directory")
+        CukeModeler::FileHelper.create_directory(:name => 'nested_directory', :directory => test_directory)
       end
 
-      let(:directory) { clazz.new(@default_file_directory) }
-      let(:nested_directory) { directory.directories.first }
+      let(:test_directory) { CukeModeler::FileHelper.create_directory }
+
+      let(:directory_model) { clazz.new(test_directory) }
+      let(:nested_directory_model) { directory_model.directories.first }
 
 
       it 'can get its directory' do
-        ancestor = nested_directory.get_ancestor(:directory)
+        ancestor = nested_directory_model.get_ancestor(:directory)
 
-        expect(ancestor).to equal(directory)
+        expect(ancestor).to equal(directory_model)
       end
 
       it 'returns nil if it does not have the requested type of ancestor' do
-        ancestor = nested_directory.get_ancestor(:example)
+        ancestor = nested_directory_model.get_ancestor(:example)
 
         expect(ancestor).to be_nil
       end
@@ -194,16 +189,12 @@ describe 'Directory, Integration' do
 
       context 'from source text' do
 
-        let(:directory_path) { "#{@default_file_directory}/test_directory" }
-        let(:directory) { clazz.new(directory_path) }
-
-        before(:each) do
-          FileUtils.mkdir(directory_path)
-        end
+        let(:directory_path) { CukeModeler::FileHelper.create_directory }
+        let(:directory_model) { clazz.new(directory_path) }
 
 
         it 'can output a directory' do
-          directory_output = directory.to_s
+          directory_output = directory_model.to_s
 
           expect(directory_output).to eq(directory_path)
         end
@@ -211,7 +202,7 @@ describe 'Directory, Integration' do
       end
 
       it 'can be remade from its own output' do
-        source = @default_file_directory
+        source = CukeModeler::FileHelper.create_directory
         directory = clazz.new(source)
 
         directory_output = directory.to_s

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

@@ -80,140 +80,133 @@ describe 'DocString, Integration' do
     describe 'getting ancestors' do
 
       before(:each) do
-        source = "#{@feature_keyword}: Test feature
-
-                    #{@scenario_keyword}: Test test
-                      #{@step_keyword} a big step:
-                    \"\"\"
-                    a
-                    doc
-                    string
-                    \"\"\""
-
-        file_path = "#{@default_file_directory}/doc_string_test_file.feature"
-        File.open(file_path, 'w') { |file| file.write(source) }
+        CukeModeler::FileHelper.create_feature_file(:text => source_gherkin, :name => 'doc_string_test_file', :directory => test_directory)
       end
 
-      let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
-      let(:doc_string) { directory.feature_files.first.feature.tests.first.steps.first.block }
+
+      let(:test_directory) { CukeModeler::FileHelper.create_directory }
+      let(:source_gherkin) { "#{@feature_keyword}: Test feature
+
+                                #{@scenario_keyword}: Test test
+                                  #{@step_keyword} a big step:
+                                \"\"\"
+                                a
+                                doc
+                                string
+                                \"\"\""
+      }
+
+      let(:directory_model) { CukeModeler::Directory.new(test_directory) }
+      let(:doc_string_model) { directory_model.feature_files.first.feature.tests.first.steps.first.block }
 
 
       it 'can get its directory' do
-        ancestor = doc_string.get_ancestor(:directory)
+        ancestor = doc_string_model.get_ancestor(:directory)
 
-        expect(ancestor).to equal(directory)
+        expect(ancestor).to equal(directory_model)
       end
 
       it 'can get its feature file' do
-        ancestor = doc_string.get_ancestor(:feature_file)
+        ancestor = doc_string_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 = doc_string.get_ancestor(:feature)
+        ancestor = doc_string_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 doc string that is part of a scenario' do
 
-        before(:each) do
-          source = "#{@feature_keyword}: Test feature
-                    
-                      #{@scenario_keyword}: Test test
-                        #{@step_keyword} a big step:
-                          \"\"\"
-                          a
-                          doc
-                          string
-                          \"\"\""
-
-          file_path = "#{@default_file_directory}/doc_string_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 big step:
+                                      \"\"\"
+                                      a
+                                      doc
+                                      string
+                                      \"\"\""
+        }
 
-        let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
-        let(:doc_string) { directory.feature_files.first.feature.tests.first.steps.first.block }
+        let(:directory_model) { CukeModeler::Directory.new(test_directory) }
+        let(:doc_string_model) { directory_model.feature_files.first.feature.tests.first.steps.first.block }
 
 
         it 'can get its scenario' do
-          ancestor = doc_string.get_ancestor(:scenario)
+          ancestor = doc_string_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 doc string that is part of an outline' do
 
-        before(:each) do
-          source = "#{@feature_keyword}: Test feature
-                    
-                      #{@outline_keyword}: Test outline
-                        #{@step_keyword} a big step:
-                          \"\"\"
-                          a
-                          doc
-                          string
-                          \"\"\"
-                      #{@example_keyword}:
-                        | param |
-                        | value |"
-
-          file_path = "#{@default_file_directory}/doc_string_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 big step:
+                                      \"\"\"
+                                      a
+                                      doc
+                                      string
+                                      \"\"\"
+        #{@example_keyword}:
+                                    | param |
+                                    | value |"
+        }
 
-        let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
-        let(:doc_string) { directory.feature_files.first.feature.tests.first.steps.first.block }
+        let(:directory_model) { CukeModeler::Directory.new(test_directory) }
+        let(:doc_string_model) { directory_model.feature_files.first.feature.tests.first.steps.first.block }
 
 
         it 'can get its outline' do
-          ancestor = doc_string.get_ancestor(:outline)
+          ancestor = doc_string_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 doc string that is part of a background' do
 
-        before(:each) do
-          source = "#{@feature_keyword}: Test feature
-                    
-                      #{@background_keyword}: Test background
-                        #{@step_keyword} a big step:
-                          \"\"\"
-                          a
-                          doc
-                          string
-                          \"\"\""
-
-          file_path = "#{@default_file_directory}/doc_string_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
+
+                                  #{@background_keyword}: Test background
+                                    #{@step_keyword} a big step:
+                                      \"\"\"
+                                      a
+                                      doc
+                                      string
+                                      \"\"\""
+        }
 
-        let(:directory) { CukeModeler::Directory.new(@default_file_directory) }
-        let(:doc_string) { directory.feature_files.first.feature.background.steps.first.block }
+        let(:directory_model) { CukeModeler::Directory.new(test_directory) }
+        let(:doc_string_model) { directory_model.feature_files.first.feature.background.steps.first.block }
 
 
         it 'can get its background' do
-          ancestor = doc_string.get_ancestor(:background)
+          ancestor = doc_string_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 'can get its step' do
-        ancestor = doc_string.get_ancestor(:step)
+        ancestor = doc_string_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 'returns nil if it does not have the requested type of ancestor' do
-        ancestor = doc_string.get_ancestor(:example)
+        ancestor = doc_string_model.get_ancestor(:example)
 
         expect(ancestor).to be_nil
       end