reek 4.7.3 → 5.0.0

data/spec/reek/code_comment_spec.rb

@@ -3,7 +3,7 @@ require_lib 'reek/code_comment'
 
 RSpec.describe Reek::CodeComment do
   context 'with an empty comment' do
-    let(:comment) { FactoryGirl.build(:code_comment, comment: '') }
+    let(:comment) { build(:code_comment, comment: '') }
 
     it 'is not descriptive' do
       expect(comment).not_to be_descriptive
@@ -14,33 +14,33 @@ RSpec.describe Reek::CodeComment do
     end
   end
 
-  context 'comment checks' do
+  describe '#descriptive' do
     it 'rejects an empty comment' do
-      comment = FactoryGirl.build(:code_comment, comment: '#')
+      comment = build(:code_comment, comment: '#')
       expect(comment).not_to be_descriptive
     end
 
     it 'rejects a 1-word comment' do
-      comment = FactoryGirl.build(:code_comment, comment: "# alpha\n#  ")
+      comment = build(:code_comment, comment: "# alpha\n#  ")
       expect(comment).not_to be_descriptive
     end
 
     it 'accepts a 2-word comment' do
-      comment = FactoryGirl.build(:code_comment, comment: '# alpha bravo  ')
+      comment = build(:code_comment, comment: '# alpha bravo  ')
       expect(comment).to be_descriptive
     end
 
     it 'accepts a multi-word comment' do
-      comment = FactoryGirl.build(:code_comment, comment: "# alpha bravo \n# charlie \n   # delta ")
+      comment = build(:code_comment, comment: "# alpha bravo \n# charlie \n   # delta ")
       expect(comment).to be_descriptive
     end
   end
 
-  context 'good comment config' do
+  describe 'good comment config' do
     it 'parses hashed options' do
       comment = '# :reek:DuplicateMethodCall { enabled: false }'
-      config = FactoryGirl.build(:code_comment,
-                                 comment: comment).config
+      config = build(:code_comment,
+                     comment: comment).config
 
       expect(config).to include('DuplicateMethodCall')
       expect(config['DuplicateMethodCall']).to include('enabled')
@@ -49,8 +49,8 @@ RSpec.describe Reek::CodeComment do
 
     it "supports hashed options with the legacy separator ':' after the smell detector" do
       comment = '# :reek:DuplicateMethodCall: { enabled: false }'
-      config = FactoryGirl.build(:code_comment,
-                                 comment: comment).config
+      config = build(:code_comment,
+                     comment: comment).config
 
       expect(config).to include('DuplicateMethodCall')
       expect(config['DuplicateMethodCall']).to include('enabled')
@@ -62,7 +62,7 @@ RSpec.describe Reek::CodeComment do
         # :reek:DuplicateMethodCall { enabled: false }
         # :reek:NestedIterators { enabled: true }
       EOF
-      config = FactoryGirl.build(:code_comment, comment: comment).config
+      config = build(:code_comment, comment: comment).config
 
       expect(config).to include('DuplicateMethodCall', 'NestedIterators')
       expect(config['DuplicateMethodCall']).to include('enabled')
@@ -75,7 +75,7 @@ RSpec.describe Reek::CodeComment do
       comment = <<-EOF
         #:reek:DuplicateMethodCall { enabled: false } and :reek:NestedIterators { enabled: true }
       EOF
-      config = FactoryGirl.build(:code_comment, comment: comment).config
+      config = build(:code_comment, comment: comment).config
 
       expect(config).to include('DuplicateMethodCall', 'NestedIterators')
       expect(config['DuplicateMethodCall']).to include('enabled')
@@ -86,7 +86,7 @@ RSpec.describe Reek::CodeComment do
 
     it 'parses multiple unhashed options on the same line' do
       comment = '# :reek:DuplicateMethodCall and :reek:NestedIterators'
-      config = FactoryGirl.build(:code_comment, comment: comment).config
+      config = build(:code_comment, comment: comment).config
 
       expect(config).to include('DuplicateMethodCall', 'NestedIterators')
       expect(config['DuplicateMethodCall']).to include('enabled')
@@ -97,7 +97,7 @@ RSpec.describe Reek::CodeComment do
 
     it 'disables the smell if no options are specifed' do
       comment = '# :reek:DuplicateMethodCall'
-      config = FactoryGirl.build(:code_comment, comment: comment).config
+      config = build(:code_comment, comment: comment).config
 
       expect(config).to include('DuplicateMethodCall')
       expect(config['DuplicateMethodCall']).to include('enabled')
@@ -105,8 +105,8 @@ RSpec.describe Reek::CodeComment do
     end
 
     it 'ignores smells after a space' do
-      config = FactoryGirl.build(:code_comment,
-                                 comment: '# :reek: DuplicateMethodCall').config
+      config = build(:code_comment,
+                     comment: '# :reek: DuplicateMethodCall').config
       expect(config).not_to include('DuplicateMethodCall')
     end
 
@@ -117,7 +117,7 @@ RSpec.describe Reek::CodeComment do
         # :reek:NestedIterators { enabled: true }
         # comment
       EOF
-      comment = FactoryGirl.build(:code_comment, comment: original_comment)
+      comment = build(:code_comment, comment: original_comment)
 
       expect(comment.send(:sanitized_comment)).to eq('Actual comment')
     end
@@ -125,66 +125,59 @@ RSpec.describe Reek::CodeComment do
 end
 
 RSpec.describe Reek::CodeComment::CodeCommentValidator do
-  context 'bad detector' do
+  context 'when the comment contains an unknown detector name' do
     it 'raises BadDetectorInCommentError' do
       expect do
-        FactoryGirl.build(:code_comment,
-                          comment: '# :reek:DoesNotExist')
+        build(:code_comment,
+              comment: '# :reek:DoesNotExist')
       end.to raise_error(Reek::Errors::BadDetectorInCommentError)
     end
   end
 
-  context 'unparsable detector configuration' do
+  context 'when the comment contains an unparsable detector configuration' do
     it 'raises GarbageDetectorConfigurationInCommentError' do
       expect do
         comment = '# :reek:UncommunicativeMethodName { thats: a: bad: config }'
-        FactoryGirl.build(:code_comment, comment: comment)
+        build(:code_comment, comment: comment)
       end.to raise_error(Reek::Errors::GarbageDetectorConfigurationInCommentError)
     end
   end
 
   describe 'validating configuration keys' do
-    context 'basic options mispelled' do
+    context 'when basic options are mispelled' do
       it 'raises BadDetectorConfigurationKeyInCommentError' do
         expect do
           # exclude -> exlude and enabled -> nabled
           comment = '# :reek:UncommunicativeMethodName { exlude: alfa, nabled: true }'
-          FactoryGirl.build(:code_comment, comment: comment)
+          build(:code_comment, comment: comment)
         end.to raise_error(Reek::Errors::BadDetectorConfigurationKeyInCommentError)
       end
     end
 
-    context 'basic options not mispelled' do
+    context 'when basic options are not mispelled' do
       it 'does not raise' do
         expect do
           comment = '# :reek:UncommunicativeMethodName { exclude: alfa, enabled: true }'
-          FactoryGirl.build(:code_comment, comment: comment)
-        end.not_to raise_error
-      end
-
-      it 'does not raise on regexps' do
-        expect do
-          comment = '# :reek:UncommunicativeMethodName { exclude: !ruby/regexp /alfa/ }'
-          FactoryGirl.build(:code_comment, comment: comment)
+          build(:code_comment, comment: comment)
         end.not_to raise_error
       end
     end
 
-    context 'unknown custom options' do
+    context 'when unknown custom options are specified' do
       it 'raises BadDetectorConfigurationKeyInCommentError' do
         expect do
           # max_copies -> mx_copies and min_clump_size -> mn_clump_size
           comment = '# :reek:DataClump { mx_copies: 4, mn_clump_size: 3 }'
-          FactoryGirl.build(:code_comment, comment: comment)
+          build(:code_comment, comment: comment)
         end.to raise_error(Reek::Errors::BadDetectorConfigurationKeyInCommentError)
       end
     end
 
-    context 'valid custom options' do
+    context 'when valid custom options are specified' do
       it 'does not raise' do
         expect do
           comment = '# :reek:DataClump { max_copies: 4, min_clump_size: 3 }'
-          FactoryGirl.build(:code_comment, comment: comment)
+          build(:code_comment, comment: comment)
         end.not_to raise_error
       end
     end

data/spec/reek/configuration/app_configuration_spec.rb

@@ -8,8 +8,8 @@ require_lib 'reek/configuration/excluded_paths'
 RSpec.describe Reek::Configuration::AppConfiguration do
   describe 'factory methods' do
     let(:expected_excluded_paths) do
-      [SAMPLES_PATH.join('two_smelly_files'),
-       SAMPLES_PATH.join('source_with_non_ruby_files')]
+      [SAMPLES_DIR.join('two_smelly_files'),
+       SAMPLES_DIR.join('source_with_non_ruby_files')]
     end
 
     let(:expected_default_directive) do
@@ -17,32 +17,35 @@ RSpec.describe Reek::Configuration::AppConfiguration do
     end
 
     let(:expected_directory_directives) do
-      { SAMPLES_PATH.join('three_clean_files') =>
+      { SAMPLES_DIR.join('three_clean_files') =>
         { Reek::SmellDetectors::UtilityFunction => { 'enabled' => false } } }
     end
 
     let(:default_directive_value) do
-      { 'IrresponsibleModule' => { 'enabled' => false } }
+      { described_class::DETECTORS_KEY =>
+        { 'IrresponsibleModule' => { 'enabled' => false } } }
     end
 
     let(:directory_directives_value) do
-      { 'samples/three_clean_files' =>
-        { 'UtilityFunction' => { 'enabled' => false } } }
+      { described_class::DIRECTORIES_KEY =>
+        { 'samples/three_clean_files' =>
+          { 'UtilityFunction' => { 'enabled' => false } } } }
     end
 
     let(:exclude_paths_value) do
-      ['samples/two_smelly_files',
-       'samples/source_with_non_ruby_files']
+      { described_class::EXCLUDE_PATHS_KEY =>
+        ['samples/two_smelly_files',
+         'samples/source_with_non_ruby_files'] }
     end
 
     let(:combined_value) do
       directory_directives_value.
         merge(default_directive_value).
-        merge('exclude_paths' => exclude_paths_value)
+        merge(exclude_paths_value)
     end
 
     describe '#from_path' do
-      let(:full_configuration_path) { CONFIG_PATH.join('full_configuration.reek') }
+      let(:full_configuration_path) { CONFIGURATION_DIR.join('full_configuration.reek') }
 
       it 'properly loads configuration and processes it' do
         config = described_class.from_path full_configuration_path
@@ -75,36 +78,40 @@ RSpec.describe Reek::Configuration::AppConfiguration do
   end
 
   describe '#directive_for' do
-    context 'multiple directory directives and no default directive present' do
+    context 'with multiple directory directives and no default directive present' do
       let(:source_via) { 'samples/three_clean_files/dummy.rb' }
-      let(:baz_config)  { { Reek::SmellDetectors::IrresponsibleModule => { enabled: false } } }
-      let(:bang_config) { { Reek::SmellDetectors::Attribute => { enabled: true } } }
+      let(:baz_config)  { { IrresponsibleModule: { enabled: false } } }
+      let(:bang_config) { { Attribute: { enabled: true } } }
+      let(:expected_result) { { Reek::SmellDetectors::Attribute => { enabled: true } } }
 
       let(:directory_directives) do
-        {
-          'samples/two_smelly_files' => baz_config,
-          'samples/three_clean_files' => bang_config
-        }
+        { described_class::DIRECTORIES_KEY =>
+          {
+            'samples/two_smelly_files' => baz_config,
+            'samples/three_clean_files' => bang_config
+          } }
       end
 
       it 'returns the corresponding directive' do
         configuration = described_class.from_hash directory_directives
-        expect(configuration.directive_for(source_via)).to eq(bang_config)
+        expect(configuration.directive_for(source_via)).to eq expected_result
       end
     end
 
-    context 'directory directive and default directive present' do
+    context 'with directory directive and default directive present' do
       let(:directory) { 'spec/samples/two_smelly_files/' }
-      let(:directory_config) { { Reek::SmellDetectors::TooManyStatements => { max_statements: 8 } } }
-      let(:directory_directives) { { directory => directory_config } }
-      let(:default_directive) do
+      let(:source_via) { "#{directory}/dummy.rb" }
+
+      let(:configuration_as_hash) do
         {
-          Reek::SmellDetectors::IrresponsibleModule => { enabled: false },
-          Reek::SmellDetectors::TooManyStatements => { max_statements: 15 }
+          described_class::DIRECTORIES_KEY =>
+            { directory => { TooManyStatements: { max_statements: 8 } } },
+          described_class::DETECTORS_KEY => {
+            IrresponsibleModule: { enabled: false },
+            TooManyStatements: { max_statements: 15 }
+          }
         }
       end
-      let(:source_via) { "#{directory}/dummy.rb" }
-      let(:configuration_as_hash) { directory_directives.merge(default_directive) }
 
       it 'returns the directory directive with the default directive reverse-merged' do
         configuration = described_class.from_hash configuration_as_hash
@@ -116,18 +123,24 @@ RSpec.describe Reek::Configuration::AppConfiguration do
       end
     end
 
-    context 'no directory directive but a default directive present' do
+    context 'with a path not covered by a directory directive but a default directive present' do
       let(:source_via) { 'spec/samples/three_clean_files/dummy.rb' }
-      let(:default_directive) { { Reek::SmellDetectors::IrresponsibleModule => { enabled: false } } }
-      let(:attribute_config) { { Reek::SmellDetectors::Attribute => { enabled: false } } }
-      let(:directory_directives) do
-        { 'spec/samples/two_smelly_files' => attribute_config }
+
+      let(:configuration_as_hash) do
+        {
+          described_class::DETECTORS_KEY => {
+            IrresponsibleModule: { enabled: false }
+          },
+          described_class::DIRECTORIES_KEY =>
+            { 'spec/samples/two_smelly_files' => { Attribute: { enabled: false } } }
+        }
       end
-      let(:configuration_as_hash) { directory_directives.merge(default_directive) }
+
+      let(:expected_result) { { Reek::SmellDetectors::IrresponsibleModule => { enabled: false } } }
 
       it 'returns the default directive' do
         configuration = described_class.from_hash configuration_as_hash
-        expect(configuration.directive_for(source_via)).to eq(default_directive)
+        expect(configuration.directive_for(source_via)).to eq expected_result
       end
     end
   end

data/spec/reek/configuration/configuration_file_finder_spec.rb

@@ -2,9 +2,13 @@ require 'fileutils'
 require 'pathname'
 require 'tmpdir'
 require_relative '../../spec_helper'
+require_lib 'reek/configuration/app_configuration'
 
 RSpec.describe Reek::Configuration::ConfigurationFileFinder do
   describe '.find' do
+    let(:regular_configuration_dir) { CONFIGURATION_DIR.join('regular_configuration') }
+    let(:regular_configuration_file) { regular_configuration_dir.join('.reek.yml') }
+
     it 'returns any explicitely passed path' do
       path = Pathname.new 'foo/bar'
       found = described_class.find(path: path)
@@ -13,42 +17,44 @@ RSpec.describe Reek::Configuration::ConfigurationFileFinder do
 
     it 'prefers an explicitely passed path over a file in current dir' do
       path = Pathname.new 'foo/bar'
-      found = described_class.find(path: path, current: SAMPLES_PATH)
+      found = described_class.find(path: path, current: regular_configuration_dir)
       expect(found).to eq(path)
     end
 
     it 'returns the file in current dir if path is not set' do
-      found = described_class.find(current: SAMPLES_PATH)
-      expect(found).to eq(SAMPLES_PATH.join('exceptions.reek'))
+      found = described_class.find(current: regular_configuration_dir)
+      expect(found).to eq(regular_configuration_file)
     end
 
     it 'returns the file in a parent dir if none in current dir' do
-      Dir.mktmpdir(nil, SAMPLES_PATH) do |tempdir|
-        found = described_class.find(current: Pathname.new(tempdir))
-        expect(found).to eq(SAMPLES_PATH.join('exceptions.reek'))
-      end
+      empty_sub_directory = CONFIGURATION_DIR.join('regular_configuration').join('empty_sub_directory')
+      found = described_class.find(current: empty_sub_directory)
+      expect(found).to eq(regular_configuration_file)
     end
 
-    it 'returns the file even if it’s just ‘.reek’' do
-      single_configuration_file_dir = CONFIG_PATH.join('single_configuration_file')
-      found = described_class.find(current: single_configuration_file_dir)
-      expect(found).to eq(single_configuration_file_dir.join('.reek'))
+    it 'skips files ending in .reek.yml in current dir' do
+      Dir.mktmpdir(nil, regular_configuration_dir) do |tempdir|
+        current = Pathname.new(tempdir)
+        bad_config = current.join('ignoreme.reek.yml')
+        FileUtils.touch bad_config
+        found = described_class.find(current: Pathname.new(tempdir))
+        expect(found).to eq(regular_configuration_file)
+      end
     end
 
     it 'returns the file in home if traversing from the current dir fails' do
       skip_if_a_config_in_tempdir
 
-      Dir.mktmpdir(nil, SAMPLES_PATH) do |tempdir|
-        found = described_class.find(current: Pathname.new(tempdir))
-        expect(found).to eq(SAMPLES_PATH.join('exceptions.reek'))
+      Dir.mktmpdir do |tempdir|
+        found = described_class.find(current: Pathname.new(tempdir), home: regular_configuration_dir)
+        expect(found).to eq(regular_configuration_file)
       end
     end
 
     it 'prefers the file in :current over one in :home' do
-      found = described_class.find(current: SAMPLES_PATH, home: CONFIG_PATH)
-      file_in_current = SAMPLES_PATH.join('exceptions.reek')
-
-      expect(found).to eq(file_in_current)
+      home_dir = CONFIGURATION_DIR.join('home')
+      found = described_class.find(current: regular_configuration_dir, home: home_dir)
+      expect(found).to eq(regular_configuration_file)
     end
 
     it 'returns nil when there are no files to find' do
@@ -68,12 +74,10 @@ RSpec.describe Reek::Configuration::ConfigurationFileFinder do
       skip_if_a_config_in_tempdir
 
       Dir.mktmpdir do |tempdir|
-        dir = Pathname.new(tempdir)
-        subdir = dir.join('subdir')
-
-        FileUtils.mkdir(subdir)
+        current = Pathname.new(tempdir)
+        home = SAMPLES_DIR.join('no_config_file')
 
-        found = described_class.find(current: subdir, home: dir)
+        found = described_class.find(current: current, home: home)
 
         expect(found).to be_nil
       end
@@ -81,7 +85,7 @@ RSpec.describe Reek::Configuration::ConfigurationFileFinder do
 
     it 'works with paths that need escaping' do
       Dir.mktmpdir("ma\ngic d*r") do |tempdir|
-        config = Pathname.new("#{tempdir}/ma\ngic f*le.reek")
+        config = Pathname.new("#{tempdir}/.reek.yml")
         subdir = Pathname.new("#{tempdir}/ma\ngic subd*r")
         FileUtils.touch config
         FileUtils.mkdir subdir
@@ -89,42 +93,122 @@ RSpec.describe Reek::Configuration::ConfigurationFileFinder do
         expect(found).to eq(config)
       end
     end
-
-    context 'more than one configuration file' do
-      let(:path) { CONFIG_PATH.join('more_than_one_configuration_file') }
-
-      it 'prints a message on STDERR' do
-        expected_message = "Error: Found multiple configuration files 'regular.reek', 'todo.reek'"
-        expect do
-          begin
-            described_class.find(current: path)
-          rescue SystemExit
-          end
-        end.to output(/#{expected_message}/).to_stderr
-      end
-
-      it 'exits' do
-        Reek::CLI::Silencer.silently do
-          expect do
-            described_class.find(current: path)
-          end.to raise_error(SystemExit)
-        end
-      end
-    end
   end
 
   describe '.load_from_file' do
     let(:sample_configuration_loaded) do
       {
-        'UncommunicativeVariableName' => { 'enabled' => false },
-        'UncommunicativeMethodName'   => { 'enabled' => false }
+        Reek::Configuration::AppConfiguration::DETECTORS_KEY => {
+          'UncommunicativeVariableName' => { 'enabled' => false },
+          'UncommunicativeMethodName'   => { 'enabled' => false }
+        }
       }
     end
 
     it 'loads the configuration from given file' do
-      configuration = described_class.load_from_file(CONFIG_PATH.join('full_mask.reek'))
+      configuration = described_class.load_from_file(CONFIGURATION_DIR.join('full_mask.reek'))
       expect(configuration).to eq(sample_configuration_loaded)
     end
+
+    context 'with exclude, accept and reject settings' do
+      context 'when configuring top level detectors' do
+        let(:configuration) do
+          described_class.
+            load_from_file(CONFIGURATION_DIR.join('accepts_rejects_and_excludes_for_detectors.reek.yml')).
+            fetch(Reek::Configuration::AppConfiguration::DETECTORS_KEY)
+        end
+
+        let(:expected) do
+          {
+            'UnusedPrivateMethod' => { 'exclude' => [/exclude regexp/] },
+            'UncommunicativeMethodName' => { 'reject' => ['reject name'],
+                                             'accept' => ['accept name'] },
+            'UncommunicativeModuleName' => { 'reject' => ['reject name 1', 'reject name 2'],
+                                             'accept' => ['accept name 1', 'accept name 2'] },
+            'UncommunicativeParameterName' => { 'reject' => ['reject name', /reject regexp/],
+                                                'accept' => ['accept name', /accept regexp/] },
+            'UncommunicativeVariableName' => { 'reject' => [/^reject regexp$/],
+                                               'accept' => [/accept(.*)regexp/] }
+          }
+        end
+
+        it 'converts marked strings to regexes' do
+          expect(configuration['UnusedPrivateMethod']).to eq(expected['UnusedPrivateMethod'])
+        end
+
+        it 'leaves regular single strings untouched' do
+          expect(configuration['UncommunicativeMethodName']).to eq(expected['UncommunicativeMethodName'])
+        end
+
+        it 'leaves regular multiple strings untouched' do
+          expect(configuration['UncommunicativeModuleName']).to eq(expected['UncommunicativeModuleName'])
+        end
+
+        it 'allows mixing of regular strings and marked strings' do
+          expect(configuration['UncommunicativeParameterName']).to eq(expected['UncommunicativeParameterName'])
+        end
+
+        it 'converts more complex marked strings correctly to regexes' do
+          expect(configuration['UncommunicativeVariableName']).to eq(expected['UncommunicativeVariableName'])
+        end
+      end
+
+      context 'when configuring directory directives' do
+        let(:directory_name) { 'app/controllers' }
+        let(:configuration) do
+          described_class.
+            load_from_file(CONFIGURATION_DIR.join('accepts_rejects_and_excludes_for_directory_directives.reek.yml')).
+            fetch(Reek::Configuration::AppConfiguration::DIRECTORIES_KEY)
+        end
+
+        let(:expected) do
+          {
+            directory_name => {
+              'UnusedPrivateMethod' => { 'exclude' => [/exclude regexp/] },
+              'UncommunicativeMethodName' => { 'reject' => ['reject name'],
+                                               'accept' => ['accept name'] },
+              'UncommunicativeModuleName' => { 'reject' => ['reject name 1', 'reject name 2'],
+                                               'accept' => ['accept name 1', 'accept name 2'] },
+              'UncommunicativeParameterName' => { 'reject' => ['reject name', /reject regexp/],
+                                                  'accept' => ['accept name', /accept regexp/] },
+              'UncommunicativeVariableName' => { 'reject' => [/^reject regexp$/],
+                                                 'accept' => [/accept(.*)regexp/] }
+            }
+          }
+        end
+
+        it 'converts marked strings to regexes' do
+          expect(configuration[directory_name]['UnusedPrivateMethod']).
+            to eq(expected[directory_name]['UnusedPrivateMethod'])
+        end
+
+        it 'leaves regular single strings untouched' do
+          expect(configuration[directory_name]['UncommunicativeMethodName']).
+            to eq(expected[directory_name]['UncommunicativeMethodName'])
+        end
+
+        it 'leaves regular multiple strings untouched' do
+          expect(configuration[directory_name]['UncommunicativeModuleName']).
+            to eq(expected[directory_name]['UncommunicativeModuleName'])
+        end
+
+        it 'allows mixing of regular strings and marked strings' do
+          expect(configuration[directory_name]['UncommunicativeParameterName']).
+            to eq(expected[directory_name]['UncommunicativeParameterName'])
+        end
+
+        it 'converts more complex marked strings correctly to regexes' do
+          expect(configuration[directory_name]['UncommunicativeVariableName']).
+            to eq(expected[directory_name]['UncommunicativeVariableName'])
+        end
+      end
+    end
+
+    it 'returns blank hash when no file is found' do
+      config = described_class.load_from_file(nil)
+
+      expect(config).to eq({})
+    end
   end
 
   private

data/spec/reek/configuration/default_directive_spec.rb

@@ -6,7 +6,7 @@ RSpec.describe Reek::Configuration::DefaultDirective do
     let(:directives) { {}.extend(described_class) }
 
     it 'adds a smell configuration' do
-      directives.add :UncommunicativeVariableName, enabled: false
+      directives.add(UncommunicativeVariableName: { enabled: false })
       expect(directives).to eq(Reek::SmellDetectors::UncommunicativeVariableName => { enabled: false })
     end
   end

data/spec/reek/configuration/directory_directives_spec.rb

@@ -1,4 +1,5 @@
 require_relative '../../spec_helper'
+require_lib 'reek/errors/config_file_error'
 require_lib 'reek/configuration/directory_directives'
 
 RSpec.describe Reek::Configuration::DirectoryDirectives do
@@ -13,13 +14,13 @@ RSpec.describe Reek::Configuration::DirectoryDirectives do
     end
     let(:source_via) { 'foo/bar/bang/dummy.rb' }
 
-    context 'our source is in a directory for which we have a directive' do
+    context 'when our source is in a directory for which we have a directive' do
       it 'returns the corresponding directive' do
         expect(directives.directive_for(source_via)).to eq(bang_config)
       end
     end
 
-    context 'our source is not in a directory for which we have a directive' do
+    context 'when our source is not in a directory for which we have a directive' do
       it 'returns nil' do
         expect(directives.directive_for('does/not/exist')).to eq(nil)
       end
@@ -31,13 +32,11 @@ RSpec.describe Reek::Configuration::DirectoryDirectives do
       {}.extend(described_class)
     end
 
-    context 'one of given paths is a file' do
-      let(:file_as_path) { SAMPLES_PATH.join('inline.rb') }
+    context 'when one of given paths is a file' do
+      let(:file_as_path) { SAMPLES_DIR.join('smelly_source').join('inline.rb') }
 
       it 'raises an error' do
-        Reek::CLI::Silencer.silently do
-          expect { directives.add(file_as_path, {}) }.to raise_error(SystemExit)
-        end
+        expect { directives.add(file_as_path => nil) }.to raise_error(Reek::Errors::ConfigFileError)
       end
     end
   end

data/spec/reek/configuration/excluded_paths_spec.rb

@@ -1,18 +1,18 @@
 require_relative '../../spec_helper'
+require_lib 'reek/errors/config_file_error'
 require_lib 'reek/configuration/excluded_paths'
 
 RSpec.describe Reek::Configuration::ExcludedPaths do
   describe '#add' do
     let(:exclusions) { [].extend(described_class) }
 
-    context 'one of given paths is a file' do
-      let(:file_as_path) { SAMPLES_PATH.join('inline.rb') }
-      let(:paths) { [SAMPLES_PATH, file_as_path] }
+    context 'when one of given paths is a file' do
+      let(:smelly_source_dir) { SAMPLES_DIR.join('smelly_source') }
+      let(:file_as_path) { smelly_source_dir.join('inline.rb') }
+      let(:paths) { [smelly_source_dir, file_as_path] }
 
       it 'raises an error if one of the given paths is a file' do
-        Reek::CLI::Silencer.silently do
-          expect { exclusions.add(paths) }.to raise_error(SystemExit)
-        end
+        expect { exclusions.add(paths) }.to raise_error(Reek::Errors::ConfigFileError)
       end
     end
   end