cuke_slicer 1.0.0 → 2.2.0

data/lib/cuke_slicer/helpers/helpers.rb

@@ -0,0 +1,23 @@
+# Internal helper module that is not part of the public API. Subject to change at any time.
+# :nodoc: all
+module CukeSlicer
+  module Helpers
+
+    def str_regex?(parameter)
+      parameter.is_a?(String) or parameter.is_a?(Regexp)
+    end
+
+    def str_regex_arr?(parameter)
+      parameter.is_a?(String) or parameter.is_a?(Regexp) or parameter.is_a?(Array)
+    end
+
+    def is_tag?(parameter)
+      parameter.to_s =~ /tag/
+    end
+
+    def is_path?(parameter)
+      parameter.to_s =~ /path/
+    end
+
+  end
+end

data/lib/cuke_slicer/helpers/matching_helpers.rb

@@ -0,0 +1,52 @@
+# Internal helper module that is not part of the public API. Subject to change at any time.
+# :nodoc: all
+module CukeSlicer
+  module MatchingHelpers
+
+    def matching_tag?(element, filters)
+      filters.each do |filter|
+        if filter.is_a?(Array)
+          filter_match = or_filter_match(element, filter)
+        else
+          filter_match = and_filter_match(element, filter)
+        end
+
+        return false unless filter_match
+      end
+
+      true
+    end
+
+    def and_filter_match(element, filter)
+      filter_match(element, filter)
+    end
+
+    def or_filter_match(element, filters)
+      filters.any? do |filter|
+        filter_match(element, filter)
+      end
+    end
+
+    def filter_match(element, filter)
+      tag_values = element.all_tags
+      tag_values = tag_values.collect { |tag| tag.name } unless Gem.loaded_specs['cuke_modeler'].version.version[/^[0]/]
+
+      if filter.is_a?(Regexp)
+        tag_values.any? { |tag| tag =~ filter }
+      else
+        tag_values.include?(filter)
+      end
+    end
+
+    def matching_path?(element, filters)
+      filters.any? do |filtered_path|
+        if filtered_path.is_a?(Regexp)
+          element.get_ancestor(:feature_file).path =~ filtered_path
+        else
+          element.get_ancestor(:feature_file).path == filtered_path
+        end
+      end
+    end
+
+  end
+end

data/lib/cuke_slicer/slicer.rb

@@ -1,3 +1,8 @@
+require "cuke_slicer/extractors/directory_extractor"
+require "cuke_slicer/extractors/file_extractor"
+require "cuke_slicer/filters/filter_set"
+
+
 module CukeSlicer
 
   # The object responsible for slicing up a Cucumber test suite into discrete test cases.
@@ -13,23 +18,32 @@ module CukeSlicer
     # exposes the underlying modeling objects and knowledge of how they work is then required to make good use of the
     # filter.
     #
+    # Finally, the test cases can be provided as a collection of file:line strings or as a collection of the object
+    # types used to represent test cases by the underlying modeling library.
+    #
     # @param target [String] the location that will be sliced up
     # @param filters [Hash] the filters that will be applied to the sliced test cases
-    def slice(target, filters = {}, &block)
+    # @param format [Symbol] the type of output: :file_line or :test_object
+    def slice(target, filters = {}, format, &block)
       validate_target(target)
       validate_filters(filters)
-
+      validate_format(format)
 
       begin
         target = File.directory?(target) ? CukeModeler::Directory.new(target) : CukeModeler::FeatureFile.new(target)
-      rescue Gherkin::Lexer::LexingError
-        raise(ArgumentError, "A syntax or lexing problem was encountered while trying to parse #{target}")
+      rescue => e
+        if e.message =~ /lexing|parsing/i
+          raise(ArgumentError, "A syntax or lexing problem was encountered while trying to parse #{target}")
+        else
+          raise e
+        end
+
       end
 
       if target.is_a?(CukeModeler::Directory)
-        sliced_tests = extract_test_cases_from_directory(target, filters, &block)
+        sliced_tests = DirectoryExtractor.new.extract(target, filters, format, &block)
       else
-        sliced_tests = extract_test_cases_from_file(target, filters, &block)
+        sliced_tests = FileExtractor.new.extract(target, filters, format, &block)
       end
 
       sliced_tests
@@ -51,198 +65,13 @@ module CukeSlicer
       raise(ArgumentError, "File or directory '#{target}' does not exist") unless File.exists?(target.to_s)
     end
 
-    def validate_filters(filter_sets)
-      filter_sets.each do |filter_type, filter_value|
-        raise(ArgumentError, "Unknown filter '#{filter_type}'") unless self.class.known_filters.include?(filter_type)
-        raise(ArgumentError, "Invalid filter '#{filter_value}'. Must be a String, Regexp, or Array thereof. Got #{filter_value.class}") unless filter_value.is_a?(String) or filter_value.is_a?(Regexp) or filter_value.is_a?(Array)
-
-        if filter_value.is_a?(Array)
-          validate_tag_collection(filter_value) if filter_type.to_s =~ /tag/
-          validate_path_collection(filter_value) if filter_type.to_s =~ /path/
-        end
-      end
-    end
-
-    def validate_tag_collection(filter_collection)
-      filter_collection.each do |filter|
-        raise(ArgumentError, "Filter '#{filter}' must be a String, Regexp, or Array. Got #{filter.class}") unless filter.is_a?(String) or filter.is_a?(Regexp) or filter.is_a?(Array)
-
-        validate_nested_tag_collection(filter) if filter.is_a?(Array)
-      end
-    end
-
-    def validate_nested_tag_collection(filter_collection)
-      filter_collection.each do |filter|
-        raise(ArgumentError, "Tag filters cannot be nested more than one level deep.") if filter.is_a?(Array)
-        raise(ArgumentError, "Filter '#{filter}' must be a String or Regexp. Got #{filter.class}") unless filter.is_a?(String) or filter.is_a?(Regexp)
-      end
-    end
-
-    def validate_path_collection(filter_collection)
-      filter_collection.each do |filter|
-        raise(ArgumentError, "Filter '#{filter}' must be a String or Regexp. Got #{filter.class}") unless filter.is_a?(String) or filter.is_a?(Regexp)
-      end
-    end
-
-    def extract_test_cases_from_directory(target, filters, &block)
-      entries = Dir.entries(target.path)
-      entries.delete '.'
-      entries.delete '..'
-
-      Array.new.tap do |test_cases|
-        entries.each do |entry|
-          entry = "#{target.path}/#{entry}"
-
-          case
-            when File.directory?(entry)
-              test_cases.concat(extract_test_cases_from_directory(CukeModeler::Directory.new(entry), filters, &block))
-            when entry =~ /\.feature$/
-              test_cases.concat(extract_test_cases_from_file(CukeModeler::FeatureFile.new(entry), filters, &block))
-            else
-              # Non-feature files are ignored
-          end
-        end
-      end
+    def validate_filters(filters)
+      filter_sets = filters.map { |filter_type, value| FilterSet.new(filter_type, value) }
+      filter_sets.each(&:validate)
     end
 
-    def extract_test_cases_from_file(target, filters, &block)
-      Array.new.tap do |test_cases|
-        unless target.feature.nil?
-          tests = target.feature.tests
-
-          runnable_elements = extract_runnable_elements(extract_runnable_block_elements(tests, filters))
-
-          apply_custom_filter(runnable_elements, &block)
-
-          runnable_elements.each do |element|
-            test_cases << "#{element.get_ancestor(:feature_file).path}:#{element.source_line}"
-          end
-        end
-      end
-    end
-
-    def extract_runnable_block_elements(things, filters)
-      Array.new.tap do |elements|
-        things.each do |thing|
-          if thing.is_a?(CukeModeler::Outline)
-            elements.concat(thing.examples)
-          else
-            elements << thing
-          end
-        end
-
-        filter_excluded_paths(elements, filters[:excluded_paths])
-        filter_included_paths(elements, filters[:included_paths])
-        filter_excluded_tags(elements, filters[:excluded_tags])
-        filter_included_tags(elements, filters[:included_tags])
-      end
-    end
-
-    def extract_runnable_elements(things)
-      Array.new.tap do |elements|
-        things.each do |thing|
-          if thing.is_a?(CukeModeler::Example)
-            # Slicing in order to remove the parameter row element
-            elements.concat(thing.row_elements.slice(1, thing.row_elements.count - 1))
-          else
-            elements << thing
-          end
-        end
-      end
-    end
-
-    def apply_custom_filter(elements, &block)
-      if block
-        elements.reject! do |element|
-          block.call(element)
-        end
-      end
-    end
-
-    def filter_excluded_tags(elements, filters)
-      if filters
-        filters = [filters] unless filters.is_a?(Array)
-
-        unless filters.empty?
-          elements.reject! do |element|
-            matching_tag?(element, filters)
-          end
-        end
-      end
-    end
-
-    def filter_included_tags(elements, filters)
-      if filters
-        filters = [filters] unless filters.is_a?(Array)
-
-        elements.keep_if do |element|
-          matching_tag?(element, filters)
-        end
-      end
-    end
-
-    def filter_excluded_paths(elements, filters)
-      if filters
-        filters = [filters] unless filters.is_a?(Array)
-
-        elements.reject! do |element|
-          matching_path?(element, filters)
-        end
-      end
-    end
-
-    def filter_included_paths(elements, filters)
-      if filters
-        filters = [filters] unless filters.is_a?(Array)
-
-        unless filters.empty?
-          elements.keep_if do |element|
-            matching_path?(element, filters)
-          end
-        end
-      end
-    end
-
-    def matching_tag?(element, filters)
-      filters.each do |filter|
-        if filter.is_a?(Array)
-          filter_match = or_filter_match(element, filter)
-        else
-          filter_match = and_filter_match(element, filter)
-        end
-
-        return false unless filter_match
-      end
-
-      true
-    end
-
-    def and_filter_match(element, filter)
-      filter_match(element, filter)
-    end
-
-    def or_filter_match(element, filters)
-      filters.any? do |filter|
-        filter_match(element, filter)
-      end
-    end
-
-    def filter_match(element, filter)
-      if filter.is_a?(Regexp)
-        element.all_tags.any? { |tag| tag =~ filter }
-      else
-        element.all_tags.include?(filter)
-      end
-    end
-
-    def matching_path?(element, filters)
-      filters.any? do |filtered_path|
-        if filtered_path.is_a?(Regexp)
-          element.get_ancestor(:feature_file).path =~ filtered_path
-        else
-          element.get_ancestor(:feature_file).path == filtered_path
-        end
-      end
+    def validate_format(format)
+      raise(ArgumentError, "Invalid Output Format: #{format}") unless [:test_object, :file_line].include?(format)
     end
 
   end

data/lib/cuke_slicer/version.rb

@@ -1,4 +1,4 @@
 module CukeSlicer
   # The current version for the gem.
-  VERSION = "1.0.0"
+  VERSION = "2.2.0"
 end

data/spec/cuke_slicer_spec.rb

@@ -1,4 +1,6 @@
 require 'spec_helper'
+require "#{File.dirname(__FILE__)}/spec_helper"
+require 'rubygems/mock_gem_ui'
 
 
 describe 'CukeSlicer, Unit' do
@@ -10,4 +12,17 @@ describe 'CukeSlicer, Unit' do
     expect(Kernel.const_defined?(:CukeSlicer)).to be true
   end
 
+  describe 'the gem' do
+
+    let(:gemspec) { eval(File.read "#{File.dirname(__FILE__)}/../cuke_slicer.gemspec") }
+
+    it 'validates cleanly' do
+      mock_ui = Gem::MockGemUi.new
+      Gem::DefaultUserInteraction.use_ui(mock_ui) { gemspec.validate }
+
+      expect(mock_ui.error).to_not match(/warn/i)
+    end
+
+  end
+
 end

data/spec/slicer_integration_spec.rb

@@ -3,74 +3,130 @@ require 'spec_helper'
 
 describe 'Slicer, Integration' do
 
-  let!(:clazz) { CukeSlicer::Slicer }
+  let(:clazz) { CukeSlicer::Slicer }
   let(:slicer) { clazz.new }
   let(:test_file) { "#{@default_file_directory}/a_test.feature" }
+  let(:test_file_text) { "Feature: Test feature
 
-  before(:each) do
-    file_text = "Feature: Test feature
-
-                   @tag
-                   Scenario: Test scenario
-                     * some step"
+                          @tag
+                          Scenario: Test scenario
+                            * some step" }
 
-    File.open(test_file, 'w') { |file| file.write(file_text) }
+  before(:each) do
+    File.write(test_file, test_file_text)
   end
 
 
   describe 'slicing' do
 
-    it 'slicing returns a collection of test cases' do
-      slice_output = slicer.slice(test_file)
+    describe 'output' do
+
+      it 'slicing returns a collection of test source lines' do
+        slice_output = slicer.slice(test_file, :file_line)
+
+        expect(slice_output).to be_an(Array)
+        expect(slice_output).to_not be_empty
+
+        slice_output.each do |test_case|
+          # Test cases come in 'file_path:line_number' format
+          expect(test_case).to match(/^.+:\d+$/)
+        end
+      end
+
+      it 'slicing returns a collection of test objects' do
+        slice_output = slicer.slice(test_file, :test_object)
+
+        expect(slice_output).to be_an(Array)
+        expect(slice_output).to_not be_empty
 
-      expect(slice_output).to be_an(Array)
-      expect(slice_output).to_not be_empty
+        slice_output.each do |test_case|
+          # Test cases come as test objects
+          expect(test_case).to be_a(CukeModeler::Scenario).or be_a(CukeModeler::Row)
+        end
+      end
 
-      slice_output.each do |test_case|
-        # Test cases come in 'file_path:line_number' format
-        expect(test_case).to match(/^.+:\d+$/)
+      it 'complains if told to provide output in an unknown format' do
+        expect { slicer.slice(test_file, :bad_option) }.to raise_error(ArgumentError, /Invalid Output Format/)
       end
+
     end
 
     it 'can slice without being provided filters' do
-      expect { slicer.slice(test_file) }.to_not raise_error
+      expect { slicer.slice(test_file, :file_line) }.to_not raise_error
     end
 
     it 'uses the custom filter, if provided' do
-      expect { |test_block| slicer.slice(@default_file_directory, &test_block) }.to yield_control
-      expect { slicer.slice(@default_file_directory) }.to_not raise_error
+      expect { |test_block| slicer.slice(@default_file_directory, :file_line, &test_block) }.to yield_control
+      expect { slicer.slice(@default_file_directory, :file_line) }.to_not raise_error
     end
 
     it 'can slice an empty feature file' do
       File.open(test_file, 'w') { |file| file.write('') }
 
-      expect { slicer.slice(test_file) }.to_not raise_error
+      expect { slicer.slice(test_file, :file_line) }.to_not raise_error
     end
 
     it 'can slice a feature that has no tests' do
       File.open(test_file, 'w') { |file| file.write('Feature: Empty feature') }
 
-      expect { slicer.slice(test_file) }.to_not raise_error
+      expect { slicer.slice(test_file, :file_line) }.to_not raise_error
     end
 
     it 'can slice a directory that contains non-feature files' do
       File.open("#{@default_file_directory}/not_a_feature.file", 'w') { |file| file.write('foobar') }
 
-      expect { slicer.slice(@default_file_directory) }.to_not raise_error
+      expect { slicer.slice(@default_file_directory, :file_line) }.to_not raise_error
     end
 
 
     describe 'target validation' do
 
       it 'complains if told to slice a non-existent location' do
-        expect { slicer.slice('does/not/exist') }.to raise_error(ArgumentError, /does not exist/)
-        expect { slicer.slice(nil) }.to raise_error(ArgumentError, /does not exist/)
+        expect { slicer.slice('does/not/exist', :file_line) }.to raise_error(ArgumentError, /does not exist/)
+        expect { slicer.slice(nil, :file_line) }.to raise_error(ArgumentError, /does not exist/)
       end
 
       it 'complains if told to slice an incorrectly formatted feature file' do
         File.open(test_file, 'w') { |file| file.write('foobar') }
 
-        expect { slicer.slice(test_file) }.to raise_error(ArgumentError, /syntax.*lexing problem.*#{test_file}/i)
+        expect { slicer.slice(test_file, :file_line) }.to raise_error(ArgumentError, /syntax.*lexing problem.*#{test_file}/i)
+      end
+
+      it 'does not swallow unexpected exceptions while slicing' do
+        begin
+          $old_method = CukeModeler::Parsing.method(:parse_text)
+
+          # Custom error type in order to ensure that we are throwing the correct thing
+          module CukeSlicer
+            class TestError < StandardError
+            end
+          end
+
+          # Monkey patch the parsing method to throw the error that we need for testing
+          module CukeModeler
+            module Parsing
+              class << self
+                def parse_text(*args)
+                  raise(CukeSlicer::TestError, 'something went wrong')
+                end
+              end
+            end
+          end
+
+
+          File.write(test_file, 'junk text')
+
+          expect { slicer.slice(test_file, :file_line) }.to raise_error(CukeSlicer::TestError, 'something went wrong')
+        ensure
+          # Making sure that our changes don't escape a test and ruin the rest of the suite
+          module CukeModeler
+            module Parsing
+              class << self
+                define_method(:parse_text, $old_method)
+              end
+            end
+          end
+        end
       end
 
     end
@@ -84,13 +140,13 @@ describe 'Slicer, Integration' do
       filters = clazz.known_filters
 
       filters.each do |filter|
-        not_provided = slicer.slice(test_file)
+        not_provided = slicer.slice(test_file, :file_line)
 
         case
           when filter.to_s =~ /path/
-            nothing_provided = slicer.slice(test_file, filter => [])
+            nothing_provided = slicer.slice(test_file, {filter => []}, :file_line)
           when filter.to_s =~ /tag/
-            nothing_provided = slicer.slice(test_file, filter => [])
+            nothing_provided = slicer.slice(test_file, {filter => []}, :file_line)
           else
             raise(ArgumentError, "Unknown filter '#{filter}'")
         end
@@ -114,7 +170,7 @@ describe 'Slicer, Integration' do
       expect(applied_filters.keys).to match_array(filters)
 
 
-      expect { @slice_output = slicer.slice(@default_file_directory, applied_filters, &block_filter) }.to_not raise_error
+      expect { @slice_output = slicer.slice(@default_file_directory, applied_filters, :file_line, &block_filter) }.to_not raise_error
       expect(@slice_output).to be_an(Array)
       expect(@slice_output).to_not be_empty
     end
@@ -126,11 +182,11 @@ describe 'Slicer, Integration' do
         path_filter_types = clazz.known_filters.select { |filter| filter.to_s =~ /path/ }
 
         path_filter_types.each do |filter|
-          expect { slicer.slice(@default_file_directory, filter => '@some_value') }.to_not raise_error
-          expect { slicer.slice(@default_file_directory, filter => /some_pattern/) }.to_not raise_error
-          expect { slicer.slice(@default_file_directory, filter => ['@some_value', /some_pattern/]) }.to_not raise_error
-          expect { slicer.slice(@default_file_directory, filter => :something_else) }.to raise_error(ArgumentError, /must be a/i)
-          expect { slicer.slice(@default_file_directory, filter => [:something_else]) }.to raise_error(ArgumentError, /must be a/i)
+          expect { slicer.slice(@default_file_directory, {filter => '@some_value'}, :file_line) }.to_not raise_error
+          expect { slicer.slice(@default_file_directory, {filter => /some_pattern/}, :file_line)}.to_not raise_error
+          expect { slicer.slice(@default_file_directory, {filter => ['@some_value', /some_pattern/]}, :file_line)}.to_not raise_error
+          expect { slicer.slice(@default_file_directory, {filter => :something_else}, :file_line) }.to raise_error(ArgumentError, /must be a/i)
+          expect { slicer.slice(@default_file_directory, {filter => [:something_else]}, :file_line) }.to raise_error(ArgumentError, /must be a/i)
         end
       end
 
@@ -138,13 +194,13 @@ describe 'Slicer, Integration' do
         tag_filter_types = clazz.known_filters.select { |filter| filter.to_s =~ /tag/ }
 
         tag_filter_types.each do |filter|
-          expect { slicer.slice(@default_file_directory, filter => '@some_value') }.to_not raise_error
-          expect { slicer.slice(@default_file_directory, filter => /some_pattern/) }.to_not raise_error
-          expect { slicer.slice(@default_file_directory, filter => ['@some_value', /some_pattern/]) }.to_not raise_error
-          expect { slicer.slice(@default_file_directory, filter => ['@some_value', [/nested_pattern/]]) }.to_not raise_error
-          expect { slicer.slice(@default_file_directory, filter => ['@some_value', [/nested_pattern/, :bad_value]]) }.to raise_error(ArgumentError, /must be a/i)
-          expect { slicer.slice(@default_file_directory, filter => :something_else) }.to raise_error(ArgumentError, /must be a/i)
-          expect { slicer.slice(@default_file_directory, filter => [:something_else]) }.to raise_error(ArgumentError, /must be a/i)
+          expect { slicer.slice(@default_file_directory, {filter => '@some_value'}, :file_line) }.to_not raise_error
+          expect { slicer.slice(@default_file_directory, {filter => /some_pattern/}, :file_line) }.to_not raise_error
+          expect { slicer.slice(@default_file_directory, {filter => ['@some_value', /some_pattern/]}, :file_line) }.to_not raise_error
+          expect { slicer.slice(@default_file_directory, {filter => ['@some_value', [/nested_pattern/]]}, :file_line) }.to_not raise_error
+          expect { slicer.slice(@default_file_directory, {filter => ['@some_value', [/nested_pattern/, :bad_value]]}, :file_line) }.to raise_error(ArgumentError, /must be a/i)
+          expect { slicer.slice(@default_file_directory, {filter => :something_else}, :file_line) }.to raise_error(ArgumentError, /must be a/i)
+          expect { slicer.slice(@default_file_directory, {filter => [:something_else]}, :file_line) }.to raise_error(ArgumentError, /must be a/i)
         end
       end
 
@@ -152,8 +208,8 @@ describe 'Slicer, Integration' do
         tag_filter_types = clazz.known_filters.select { |filter| filter.to_s =~ /tag/ }
 
         tag_filter_types.each do |filter|
-          expect { slicer.slice(@default_file_directory, filter => ['@some_value', [/nested_pattern/]]) }.to_not raise_error
-          expect { slicer.slice(@default_file_directory, filter => ['@some_value', [/nested_pattern/, ['way_too_nested']]]) }.to raise_error(ArgumentError, /cannot.* nested/i)
+          expect { slicer.slice(@default_file_directory, {filter => ['@some_value', [/nested_pattern/]]}, :file_line) }.to_not raise_error
+          expect { slicer.slice(@default_file_directory, {filter => ['@some_value', [/nested_pattern/, ['way_too_nested']]]}, :file_line) }.to raise_error(ArgumentError, /cannot.* nested/i)
         end
       end
 
@@ -161,11 +217,63 @@ describe 'Slicer, Integration' do
         unknown_filter_type = :unknown_filter
         options = {unknown_filter_type => 'foo'}
 
-        expect { slicer.slice(@default_file_directory, options) }.to raise_error(ArgumentError, /unknown filter.*#{unknown_filter_type}/i)
+        expect { slicer.slice(@default_file_directory, options, :file_line) }.to raise_error(ArgumentError, /unknown filter.*#{unknown_filter_type}/i)
       end
 
     end
 
   end
 
+  describe "bugs that we don't want to happen again" do
+
+
+    # As a nested directory structure was being traversed for slicing, the extraction algorithm was mangling the
+    # current file path such that it would sometimes attempt to search non-existent locations. Sometimes this
+    # resulted in an exception and sometimes this resulted in files getting silently skipped over.
+
+
+    it 'can handle a realistically nested directory structure' do
+      root_directory = @default_file_directory
+
+      # Outer 'before' hook already makes a root level feature file
+      expected_tests = ["#{test_file}:4"]
+
+      # Adding a nested directory
+      nested_directory_1 = "#{root_directory}/nested_directory_1"
+      FileUtils.mkpath(nested_directory_1)
+      test_file = "#{nested_directory_1}/nested_file_1.feature"
+      File.write(test_file, test_file_text)
+      expected_tests << "#{test_file}:4"
+      test_file = "#{nested_directory_1}/nested_file_2.feature"
+      File.write(test_file, test_file_text)
+      expected_tests << "#{test_file}:4"
+
+      # And another one
+      nested_directory_2 = "#{root_directory}/nested_directory_2"
+      FileUtils.mkpath(nested_directory_2)
+      test_file = "#{nested_directory_2}/nested_file_1.feature"
+      File.write(test_file, test_file_text)
+      expected_tests << "#{test_file}:4"
+      test_file = "#{nested_directory_2}/nested_file_2.feature"
+      File.write(test_file, test_file_text)
+      expected_tests << "#{test_file}:4"
+
+      # And one of them has another directory inside of it
+      doubly_nested_directory = "#{nested_directory_1}/doubly_nested_directory"
+      FileUtils.mkpath(doubly_nested_directory)
+      test_file = "#{doubly_nested_directory}/doubly_nested_file_1.feature"
+      File.write(test_file, test_file_text)
+      expected_tests << "#{test_file}:4"
+      test_file = "#{doubly_nested_directory}/doubly_nested_file_2.feature"
+      File.write(test_file, test_file_text)
+      expected_tests << "#{test_file}:4"
+
+
+      # No problems, no missed files
+      expect { @slice_output = slicer.slice(root_directory, :file_line) }.to_not raise_error
+      expect(@slice_output).to match_array(expected_tests)
+    end
+
+  end
+
 end