cuke_slicer 2.2.0 → 3.0.0

data/features/step_definitions/setup_steps.rb

@@ -1,103 +0,0 @@
-Given(/^the following feature file(?: "([^"]*)")?:$/) do |file_name, file_text|
-  @test_directory ||= @default_file_directory
-  file_name ||= @default_feature_file_name
-
-  @targets ||= []
-  @targets << file_name
-
-  File.open("#{@test_directory}/#{file_name}", 'w') { |file| file.write(file_text) }
-end
-
-Given(/^the directory "([^"]*)"$/) do |directory_name|
-  @test_directory = "#{@default_file_directory}/#{directory_name}"
-
-  FileUtils.mkdir(@test_directory)
-end
-
-Given(/^the following tag filters:$/) do |filters|
-  filters.hashes.each do |filter|
-    case filter['filter type']
-      when 'excluded'
-        @excluded_tag_filters = filter['filter']
-      when 'included'
-        @included_tag_filters = filter['filter']
-      else
-        raise("Unknown filter type #{filter['filter type']}")
-    end
-  end
-end
-
-And(/^the following path filters:$/) do |filters|
-  @excluded_path_filters = []
-  @included_path_filters = []
-
-  filters.hashes.each do |filter|
-    case filter['filter type']
-      when 'excluded'
-        @excluded_path_filters << process_filter(filter['filter'])
-      when 'included'
-        @included_path_filters << process_filter(filter['filter'])
-      else
-        raise("Unknown filter type #{filter['filter type']}")
-    end
-  end
-end
-
-And(/^the following custom filter:$/) do |filter|
-  @custom_filter = eval("Proc.new #{filter}")
-end
-
-Given(/^the file "([^"]*)" does not exist$/) do |file_name|
-  @test_directory ||= @default_file_directory
-
-  @targets ||= []
-  @targets << file_name
-
-  file_path = "#{@test_directory}/#{file_name}"
-  FileUtils.rm(file_path) if File.exists?(file_path)
-end
-
-Given(/^the directory "([^"]*)" does not exist$/) do |directory_name|
-  @targets ||= []
-  @targets << directory_name
-
-  file_path = "#{@default_file_directory}/#{directory_name}"
-  FileUtils.remove_dir(file_path) if File.exists?(file_path)
-end
-
-And(/^the file "([^"]*)"$/) do |file_name|
-  @test_directory ||= @default_file_directory
-
-  @targets ||= []
-  @targets << file_name
-
-  File.open("#{@test_directory}/#{file_name}", 'w') { |file| file.write('') }
-end
-
-Given(/^a slicer$/) do
-  @slicer = CukeSlicer::Slicer.new
-end
-
-And(/^the test cases are to be extracted as objects$/) do
-  @output_type = :test_object
-end
-
-And(/^an invalid output option$/) do
-  @output_type = :invalid_option
-end
-
-Given(/^a test suite to extract from$/) do
-  @test_directory ||= @default_file_directory
-
-  @targets ||= []
-  @targets << @default_feature_file_name
-
-
-  test_suite = "Feature: Test feature
-
-                   @tag
-                   Scenario: Test scenario
-                     * some step"
-
-  File.write("#{@test_directory}/#{@default_feature_file_name}", test_suite)
-end

data/features/step_definitions/verification_steps.rb

@@ -1,58 +0,0 @@
-Then(/^the following test cases are found$/) do |expected_test_cases|
-  expected_test_cases = expected_test_cases.raw.flatten
-  expected_test_cases.collect! { |test_case| test_case.sub('path/to', @default_file_directory) }
-
-  found_test_cases = @output.values.flatten
-
-  expect(found_test_cases).to match_array(expected_test_cases)
-end
-
-Then(/^no test cases are found$/) do
-  expect(@output.values.flatten).to be_empty
-end
-
-Then(/^The following filter types are valid:$/) do |filter_types|
-  filter_types = filter_types.raw.flatten.collect { |filter| filter.to_sym }
-
-  expect(CukeSlicer::Slicer.known_filters).to match_array(filter_types)
-end
-
-Then(/^"([^"]*)" are found$/) do |test_cases|
-  expected_test_cases = test_cases.delete(' ').split(',')
-  expected_test_cases.collect! { |test_case| test_case.sub('path/to', @default_file_directory) }
-
-  found_test_cases = @output.values.flatten
-
-  expect(found_test_cases).to match_array(expected_test_cases)
-end
-
-Then(/^an error indicating that the (?:file|directory) does not exist will be triggered$/) do
-  expect(@error_raised).to_not be_nil
-  expect(@error_raised.message).to match(/file.*directory.*does not exist/i)
-end
-
-Then(/^an error indicating that the feature file is invalid will be triggered$/) do
-  expect(@error_raised).to_not be_nil
-  expect(@error_raised.message).to match(/syntax.*lexing/)
-end
-
-Then(/^an error indicating that the filter type is unknown will be triggered$/) do
-  expect(@error_raised).to_not be_nil
-  expect(@error_raised.message).to match(/unknown filter/i)
-end
-
-Then(/^an error indicating that the filter is invalid will be triggered$/) do
-  expect(@error_raised).to_not be_nil
-  expect(@error_raised.message).to match(/invalid filter/i)
-end
-
-Then(/^the test cases are provided as objects$/) do
-  @output.values.flatten.each do |output|
-    expect(output).to be_a(CukeModeler::Scenario).or be_a(CukeModeler::Row)
-  end
-end
-
-Then(/^an error indicating that the output type is invalid will be triggered$/) do
-  expect(@error_raised).to_not be_nil
-  expect(@error_raised.message).to match(/Invalid Output Format/i)
-end

data/features/support/env.rb

@@ -1,18 +0,0 @@
-require 'simplecov'
-SimpleCov.command_name('cuke_slicer-cucumber_tests')
-
-
-require 'cuke_slicer'
-
-
-Before do
-  feature_directory = "#{File.dirname(__FILE__)}/.."
-  @default_file_directory = "#{feature_directory}/temp_files"
-  @default_feature_file_name = 'unnamed_feature.feature'
-
-  FileUtils.mkdir(@default_file_directory)
-end
-
-After do
-  FileUtils.remove_dir(@default_file_directory, true)
-end

data/gemfiles/cuke_modeler0.gemfile

@@ -1,28 +0,0 @@
-# Older Rubies on Windows cannot securely connect to RubyGems anymore (https://github.com/rubygems/rubygems/issues/2330)
-if (RbConfig::CONFIG['host_os'] =~ /mswin|msys|mingw32/) && (RUBY_VERSION =~ /^1\./)
-  source 'http://rubygems.org'
-else
-  source 'https://rubygems.org'
-end
-
-gemspec :path => "../"
-
-# Using the most recent release of the 0.x series in order to have all of the bug fixes.
-gem 'cuke_modeler', '0.4.1'
-
-if RUBY_VERSION =~ /^1\./
-  gem 'cucumber', '< 3.0.0' # Ruby 1.9.x support dropped after this version
-  gem 'ffi', '< 1.9.15' # The 'ffi' gem requires Ruby 2.x on/after this version
-  gem 'json', '< 2.0' # The 'json' gem drops pre-Ruby 2.x support on/after this version
-  gem 'mime-types', '< 3.0.0' # The 'mime-types' gem requires Ruby 2.x on/after this version
-  gem 'rainbow', '< 3.0' # The 'rainbow' gem requires Ruby 2.x on/after this version
-  gem 'rake', '< 12.3.0' # The 'rake' gem requires Ruby 2.x on/after this version
-  gem 'rest-client', '< 2.0' # The 'rainbow' gem requires Ruby 2.x on/after this version
-  gem 'simplecov-html', '< 0.11.0' # The 'simplecov-html' gem requires Ruby 2.x on/after this version
-  gem 'thor', '< 1.0' # The 'thor' gem requires Ruby 2.x on/after this version
-  gem 'tins', '< 1.7' # The 'tins' gem requires Ruby 2.x on/after this version
-  gem 'term-ansicolor', '< 1.4' # The 'term-ansicolor' gem requires Ruby 2.x on/after this version
-  gem 'unf_ext', '< 0.0.7.3' # The 'unf_ext' gem requires Ruby 2.x on/after this version
-else
-  gem 'cucumber', '< 4.0.0' # Cucumber 4.x switches to needing the `cucumber-gherkin` gem, which is incompatible with `cuke_modeler` 0.x
-end

data/gemfiles/cuke_modeler1.gemfile

@@ -1,29 +0,0 @@
-# Older Rubies on Windows cannot securely connect to RubyGems anymore (https://github.com/rubygems/rubygems/issues/2330)
-if (RbConfig::CONFIG['host_os'] =~ /mswin|msys|mingw32/) && (RUBY_VERSION =~ /^1\./)
-  source 'http://rubygems.org'
-else
-  source 'https://rubygems.org'
-end
-
-gemspec :path => "../"
-
-# The version of CukeModeler being tested
-gem 'cuke_modeler', '~> 1.0'
-
-
-if RUBY_VERSION =~ /^1\./
-  gem 'cucumber', '< 3.0.0' # Ruby 1.9.x support dropped after this version
-  gem 'ffi', '< 1.9.15' # The 'ffi' gem requires Ruby 2.x on/after this version
-  gem 'json', '< 2.0' # The 'json' gem drops pre-Ruby 2.x support on/after this version
-  gem 'mime-types', '< 3.0.0' # The 'mime-types' gem requires Ruby 2.x on/after this version
-  gem 'rainbow', '< 3.0' # The 'rainbow' gem requires Ruby 2.x on/after this version
-  gem 'rake', '< 12.3.0' # The 'rake' gem requires Ruby 2.x on/after this version
-  gem 'rest-client', '< 2.0' # The 'rainbow' gem requires Ruby 2.x on/after this version
-  gem 'simplecov-html', '< 0.11.0' # The 'simplecov-html' gem requires Ruby 2.x on/after this version
-  gem 'thor', '< 1.0' # The 'thor' gem requires Ruby 2.x on/after this version
-  gem 'tins', '< 1.7' # The 'tins' gem requires Ruby 2.x on/after this version
-  gem 'term-ansicolor', '< 1.4' # The 'term-ansicolor' gem requires Ruby 2.x on/after this version
-  gem 'unf_ext', '< 0.0.7.3' # The 'unf_ext' gem requires Ruby 2.x on/after this version
-else
-  gem 'cucumber', '< 4.0.0' # Cucumber 4.x switches to needing the `cucumber-gherkin` gem, which is incompatible with `cuke_modeler` 1.x
-end

data/gemfiles/cuke_modeler2.gemfile

@@ -1,29 +0,0 @@
-# Older Rubies on Windows cannot securely connect to RubyGems anymore (https://github.com/rubygems/rubygems/issues/2330)
-if (RbConfig::CONFIG['host_os'] =~ /mswin|msys|mingw32/) && (RUBY_VERSION =~ /^1\./)
-  source 'http://rubygems.org'
-else
-  source 'https://rubygems.org'
-end
-
-gemspec :path => "../"
-
-# The version of CukeModeler being tested
-gem 'cuke_modeler', '~> 2.0'
-
-
-if RUBY_VERSION =~ /^1\./
-  gem 'cucumber', '< 3.0.0' # Ruby 1.9.x support dropped after this version
-  gem 'ffi', '< 1.9.15' # The 'ffi' gem requires Ruby 2.x on/after this version
-  gem 'json', '< 2.0' # The 'json' gem drops pre-Ruby 2.x support on/after this version
-  gem 'mime-types', '< 3.0.0' # The 'mime-types' gem requires Ruby 2.x on/after this version
-  gem 'rainbow', '< 3.0' # The 'rainbow' gem requires Ruby 2.x on/after this version
-  gem 'rake', '< 12.3.0' # The 'rake' gem requires Ruby 2.x on/after this version
-  gem 'rest-client', '< 2.0' # The 'rainbow' gem requires Ruby 2.x on/after this version
-  gem 'simplecov-html', '< 0.11.0' # The 'simplecov-html' gem requires Ruby 2.x on/after this version
-  gem 'thor', '< 1.0' # The 'thor' gem requires Ruby 2.x on/after this version
-  gem 'tins', '< 1.7' # The 'tins' gem requires Ruby 2.x on/after this version
-  gem 'term-ansicolor', '< 1.4' # The 'term-ansicolor' gem requires Ruby 2.x on/after this version
-  gem 'unf_ext', '< 0.0.7.3' # The 'unf_ext' gem requires Ruby 2.x on/after this version
-else
-  gem 'cucumber', '< 4.0.0' # Cucumber 4.x switches to needing the `cucumber-gherkin` gem, which is incompatible with `cuke_modeler` 2.x
-end

data/gemfiles/cuke_modeler3.gemfile

@@ -1,12 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec :path => "../"
-
-# The version of CukeModeler being tested
-gem 'cuke_modeler', '~> 3.0'
-
-gem 'cucumber', '2.2.0' # `cucumber` 4.x does not currently work on JRuby
-
-if RUBY_VERSION =~ /^2\.[1234]/
-  gem 'activesupport', '< 6.0' # `activesupport` 6.x requires at least Ruby 2.5
-end

data/spec/cuke_slicer_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-require "#{File.dirname(__FILE__)}/spec_helper"
-require 'rubygems/mock_gem_ui'
-
-
-describe 'CukeSlicer, Unit' do
-
-  let(:nodule) { CukeSlicer }
-
-
-  it 'is defined' 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

@@ -1,279 +0,0 @@
-require 'spec_helper'
-
-
-describe 'Slicer, Integration' do
-
-  let(:clazz) { CukeSlicer::Slicer }
-  let(:slicer) { clazz.new }
-  let(:test_file) { "#{@default_file_directory}/a_test.feature" }
-  let(:test_file_text) { "Feature: Test feature
-
-                          @tag
-                          Scenario: Test scenario
-                            * some step" }
-
-  before(:each) do
-    File.write(test_file, test_file_text)
-  end
-
-
-  describe 'slicing' do
-
-    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
-
-        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
-
-      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, :file_line) }.to_not raise_error
-    end
-
-    it 'uses the custom filter, if provided' do
-      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, :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, :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, :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', :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, :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
-
-  end
-
-
-  describe 'filtering' do
-
-    it 'treats an empty filter set as if the filter were not provided' do
-      filters = clazz.known_filters
-
-      filters.each do |filter|
-        not_provided = slicer.slice(test_file, :file_line)
-
-        case
-          when filter.to_s =~ /path/
-            nothing_provided = slicer.slice(test_file, {filter => []}, :file_line)
-          when filter.to_s =~ /tag/
-            nothing_provided = slicer.slice(test_file, {filter => []}, :file_line)
-          else
-            raise(ArgumentError, "Unknown filter '#{filter}'")
-        end
-
-        expect(nothing_provided).to eq(not_provided)
-        expect(nothing_provided).to_not be_empty
-      end
-    end
-
-    it 'can combine any and all filters' do
-      filters = clazz.known_filters
-
-      applied_filters = {excluded_tags: '@a',
-                         included_tags: /./,
-                         excluded_paths: 'a',
-                         included_paths: /./}
-
-      block_filter = eval("Proc.new { |test_case| false}")
-
-      # A reminder to update this test if new filters are added in the future
-      expect(applied_filters.keys).to match_array(filters)
-
-
-      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
-
-
-    describe 'filter validation' do
-
-      it 'will only accept string, regular expression, or collections thereof as path filters' 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'}, :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
-
-      it 'will only accept strings, regular expressions, arrays, or collections thereof as tag filters' 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'}, :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
-
-      it 'will only accept a single level of tag filter nesting' 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/]]}, :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
-
-      it 'complains if given an unknown filter' do
-        unknown_filter_type = :unknown_filter
-        options = {unknown_filter_type => 'foo'}
-
-        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

data/spec/slicer_unit_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-
-
-describe 'Slicer, Unit' do
-
-  let(:clazz) { CukeSlicer::Slicer }
-  let(:slicer) { clazz.new }
-
-
-  it 'is defined' do
-    expect(CukeSlicer.const_defined?(:Slicer)).to be true
-  end
-
-  it 'can slice individual test cases out of a larger group' do
-    expect(slicer).to respond_to(:slice)
-  end
-
-  it 'needs something to slice up, an output format, and can optionally have applicable filters' do
-    expect(slicer.method(:slice).arity).to eq(-3)
-  end
-
-  it 'knows what slice filters are available for use' do
-    expect(clazz).to respond_to(:known_filters)
-  end
-
-  it 'tracks its filters as an array of symbols' do
-    filters = clazz.known_filters
-
-    expect(filters).to be_an(Array)
-    expect(filters).to_not be_empty
-
-    filters.each do |filter|
-      expect(filter).to be_a(Symbol)
-    end
-  end
-
-end

data/spec/spec_helper.rb

@@ -1,22 +0,0 @@
-require 'simplecov'
-SimpleCov.command_name('cuke_slicer-rspec_tests')
-
-
-require 'cuke_slicer'
-
-
-RSpec.configure do |config|
-  config.before(:all) do
-    spec_directory = File.dirname(__FILE__)
-    @default_file_directory = "#{spec_directory}/temp_files"
-  end
-
-  config.before(:each) do
-    FileUtils.mkpath(@default_file_directory)
-  end
-
-  config.after(:each) do
-    FileUtils.remove_dir(@default_file_directory, true)
-  end
-
-end