reek 1.2.6 → 1.2.8

data/spec/reek/smells/control_couple_spec.rb

@@ -1,52 +1,57 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-require 'reek/smells/control_couple'
+require File.join(File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__)))), 'spec_helper')
+require File.join(File.dirname(File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__))))), 'lib', 'reek', 'smells', 'control_couple')
+require File.join(File.dirname(File.expand_path(__FILE__)), 'smell_detector_shared')
 
 include Reek::Smells
 
 describe ControlCouple do
+  before(:each) do
+    @source_name = 'lets get married'
+    @detector = ControlCouple.new(@source_name)
+  end
+
+  it_should_behave_like 'SmellDetector'
+
   context 'conditional on a parameter' do
     it 'should report a ternary check on a parameter' do
-      'def simple(arga) arga ? @ivar : 3 end'.should reek_only_of(:ControlCouple, /arga/)
+      src = 'def simple(arga) arga ? @ivar : 3 end'
+      src.should smell_of(ControlCouple, ControlCouple::PARAMETER_KEY => 'arga')
     end
     it 'should not report a ternary check on an ivar' do
-      'def simple(arga) @ivar ? arga : 3 end'.should_not reek
+      src = 'def simple(arga) @ivar ? arga : 3 end'
+      src.should_not smell_of(ControlCouple)
     end
     it 'should not report a ternary check on a lvar' do
-      'def simple(arga) lvar = 27; lvar ? arga : @ivar end'.should_not reek
+      src = 'def simple(arga) lvar = 27; lvar ? arga : @ivar end'
+      src.should_not smell_of(ControlCouple)
     end
     it 'should spot a couple inside a block' do
-      'def blocks(arg) @text.map { |blk| arg ? blk : "#{blk}" } end'.should reek_of(:ControlCouple, /arg/)
+      src = 'def blocks(arg) @text.map { |blk| arg ? blk : "#{blk}" } end'
+      src.should smell_of(ControlCouple, ControlCouple::PARAMETER_KEY => 'arg')
     end
   end
 
-  context 'parameter defaulted with boolean' do
-    context 'in a method' do
-      it 'reports a parameter defaulted to true' do
-        'def cc(arga = true) end'.should reek_of(:ControlCouple, /arga/)
-      end
-      it 'reports a parameter defaulted to false' do
-        'def cc(arga = false) end'.should reek_of(:ControlCouple, /arga/)
-      end
-      it 'reports two parameters defaulted to booleans' do
-        src = 'def cc(nowt, arga = true, argb = false, &blk) end'
-        src.should reek_of(:ControlCouple, /arga/)
-        src.should reek_of(:ControlCouple, /argb/)
-      end
+  context 'when a smell is reported' do
+    before :each do
+      src = <<EOS
+def things(arg)
+  @text.map do |blk|
+    arg ? blk : "blk"
+  end
+  puts "hello" if arg
+end
+EOS
+      ctx = MethodContext.new(nil, src.to_reek_source.syntax_tree)
+      smells = @detector.examine(ctx)
+      smells.length.should == 1
+      @warning = smells[0]
     end
 
-    context 'in a singleton method' do
-      it 'reports a parameter defaulted to true' do
-        'def self.cc(arga = true) end'.should reek_of(:ControlCouple, /arga/)
-      end
-      it 'reports a parameter defaulted to false' do
-        'def fred.cc(arga = false) end'.should reek_of(:ControlCouple, /arga/)
-      end
-      it 'reports two parameters defaulted to booleans' do
-        src = 'def Module.cc(nowt, arga = true, argb = false, &blk) end'
-        src.should reek_of(:ControlCouple, /arga/)
-        src.should reek_of(:ControlCouple, /argb/)
-      end
+    it_should_behave_like 'common fields set correctly'
+
+    it 'has the correct fields' do
+      @warning.smell[ControlCouple::PARAMETER_KEY].should == 'arg'
+      @warning.lines.should == [3,6]
     end
   end
 end

data/spec/reek/smells/data_clump_spec.rb

@@ -1,32 +1,59 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-require 'reek/smells/data_clump'
+require File.join(File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__)))), 'spec_helper')
+require File.join(File.dirname(File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__))))), 'lib', 'reek', 'smells', 'data_clump')
+require File.join(File.dirname(File.expand_path(__FILE__)), 'smell_detector_shared')
 
 include Reek::Smells
 
 shared_examples_for 'a data clump detector' do
   it 'does not report small parameter sets' do
     src = <<EOS
+# test module
 #{@context} Scrunch
   def first(pa) @field == :sym ? 0 : 3; end
   def second(pa) @field == :sym; end
   def third(pa) pa - pb + @fred; end
 end
 EOS
-
-    src.should_not reek
+    src.should_not smell_of(DataClump)
   end
 
-  it 'reports 3 identical pairs in a class' do
-    src = <<EOS
-#{@context} Scrunch
+  context 'with 3 identical pairs' do
+    before :each do
+      @module_name = 'Scrunch'
+      @src = <<EOS
+#{@context} #{@module_name}
   def first(pa, pb) @field == :sym ? 0 : 3; end
   def second(pa, pb) @field == :sym; end
   def third(pa, pb) pa - pb + @fred; end
 end
 EOS
-
-    src.should reek_of(:DataClump, /\[pa, pb\]/, /3 methods/)
+      ctx = CodeContext.new(nil, @src.to_reek_source.syntax_tree)
+      detector = DataClump.new('newt')
+      @smells = detector.examine_context(ctx)
+      @warning = @smells[0]   # SMELL: too cumbersome!
+      @yaml = @warning.to_yaml
+    end
+    it 'records only the one smell' do
+      @smells.length.should == 1
+    end
+    it 'reports all parameters' do
+      @smells[0].smell[DataClump::PARAMETERS_KEY].should == ['pa', 'pb']
+    end
+    it 'reports the number of occurrences' do
+      @smells[0].smell[DataClump::OCCURRENCES_KEY].should == 3
+    end
+    it 'reports all parameters' do
+      @smells[0].smell[DataClump::METHODS_KEY].should == ['first', 'second', 'third']
+    end
+    it 'reports the declaration line numbers' do
+      @smells[0].lines.should == [2,3,4]
+    end
+    it 'reports the correct smell class' do
+      @smells[0].smell_class.should == DataClump::SMELL_CLASS
+    end
+    it 'reports the context fq name' do
+      @smells[0].context.should == @module_name
+    end
   end
 
   it 'reports 3 swapped pairs in a class' do
@@ -37,8 +64,8 @@ EOS
   def tri(pa, pb) pa - pb + @fred; end
 end
 EOS
-
-    src.should reek_of(:DataClump, /\[pa, pb\]/, /3 methods/)
+    src.should smell_of(DataClump, {DataClump::OCCURRENCES_KEY => 3,
+      DataClump::PARAMETERS_KEY => ['pa', 'pb']})
   end
 
   it 'reports 3 identical parameter sets in a class' do
@@ -49,14 +76,11 @@ EOS
   def third(pa, pb, pc) pa - pb + @fred; end
 end
 EOS
-
-    src.should reek_of(:DataClump, /\[pa, pb, pc\]/, /3 methods/)
-    src.should_not reek_of(:DataClump, /\[pa, pb\]/, /3 methods/)
-    src.should_not reek_of(:DataClump, /\[pa, pc\]/, /3 methods/)
-    src.should_not reek_of(:DataClump, /\[pb, pc\]/, /3 methods/)
+    src.should smell_of(DataClump, {DataClump::OCCURRENCES_KEY => 3,
+      DataClump::PARAMETERS_KEY => ['pa', 'pb', 'pc']})
   end
 
-  it 'recognises re-ordered identical parameter sets' do
+  it 'reports re-ordered identical parameter sets' do
     src = <<EOS
 #{@context} Scrunch
   def first(pb, pa, pc) @field == :sym ? 0 : 3; end
@@ -64,11 +88,8 @@ EOS
   def third(pa, pb, pc) pa - pb + @fred; end
 end
 EOS
-
-    src.should reek_of(:DataClump, /\[pa, pb, pc\]/, /3 methods/)
-    src.should_not reek_of(:DataClump, /\[pa, pb\]/, /3 methods/)
-    src.should_not reek_of(:DataClump, /\[pa, pc\]/, /3 methods/)
-    src.should_not reek_of(:DataClump, /\[pb, pc\]/, /3 methods/)
+    src.should smell_of(DataClump, {DataClump::OCCURRENCES_KEY => 3,
+      DataClump::PARAMETERS_KEY => ['pa', 'pb', 'pc']})
   end
 
   it 'counts only identical parameter sets' do
@@ -79,12 +100,30 @@ EOS
   def fc(name, windowW, windowH) end
 end
 EOS
+    src.should_not smell_of(DataClump)
+  end
 
-    src.should_not reek_of(:DataClump)
+  it 'gets a real example right' do
+    src = <<EOS
+#{@context} Inline
+  def generate(src, options) end
+  def c (src, options) end
+  def c_singleton (src, options) end
+  def c_raw (src, options) end
+  def c_raw_singleton (src, options) end
+end
+EOS
+    src.should smell_of(DataClump, DataClump::OCCURRENCES_KEY => 5)
   end
 end
 
 describe DataClump do
+  before(:each) do
+    @detector = DataClump.new('newt')
+  end
+
+  it_should_behave_like 'SmellDetector'
+
   context 'in a class' do
     before :each do
       @context = 'class'

data/spec/reek/smells/duplication_spec.rb

@@ -1,77 +1,126 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-
-require 'reek/configuration'
-require 'reek/method_context'
-require 'reek/stop_context'
-require 'reek/smells/duplication'
+require File.join(File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__)))), 'spec_helper')
+require File.join(File.dirname(File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__))))), 'lib', 'reek', 'smells', 'duplication')
+require File.join(File.dirname(File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__))))), 'lib', 'reek', 'core', 'code_parser')
+require File.join(File.dirname(File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__))))), 'lib', 'reek', 'core', 'sniffer')
+require File.join(File.dirname(File.expand_path(__FILE__)), 'smell_detector_shared')
 
 include Reek
 include Reek::Smells
 
-describe Duplication, "repeated method calls" do
-  it 'should report repeated call' do
-    'def double_thing() @other.thing + @other.thing end'.should reek_only_of(:Duplication, /@other.thing/)
-  end
-
-  it 'should report repeated call to lvar' do
-    'def double_thing(other) other[@thing] + other[@thing] end'.should reek_only_of(:Duplication, /other\[@thing\]/)
-  end
-
-  it 'should report call parameters' do
-    'def double_thing() @other.thing(2,3) + @other.thing(2,3) end'.should reek_only_of(:Duplication, /@other.thing\(2, 3\)/)
-  end
-
-  it 'should report nested calls' do
-    ruby = 'def double_thing() @other.thing.foo + @other.thing.foo end'.sniff
-    ruby.should reek_of(:Duplication, /@other.thing[^\.]/)
-    ruby.should reek_of(:Duplication, /@other.thing.foo/)
-  end
+describe Duplication do
 
-  it 'should ignore calls to new' do
-    'def double_thing() @other.new + @other.new end'.should_not reek
-  end
+  context 'when a smell is reported' do
+    before :each do
+      @source_name = 'copy-cat'
+      @detector = Duplication.new(@source_name)
+      src = <<EOS
+def double_thing(other)
+  other[@thing]
+  not_the_sam(at = all)
+  other[@thing]
 end
+EOS
+      ctx = CodeContext.new(nil, src.to_reek_source.syntax_tree)
+      smells = @detector.examine_context(ctx)
+      smells.length.should == 1
+      @warning = smells[0]
+    end
 
-describe Duplication, "non-repeated method calls" do
-  it 'should not report similar calls' do
-    'def equals(other) other.thing == self.thing end'.should_not reek
-  end
+    it_should_behave_like 'SmellDetector'
+    it_should_behave_like 'common fields set correctly'
 
-  it 'should respect call parameters' do
-    'def double_thing() @other.thing(3) + @other.thing(2) end'.should_not reek
+    it 'reports the call' do
+      @warning.smell[Duplication::CALL_KEY].should == 'other[@thing]'
+    end
+    it 'reports the correct lines' do
+      @warning.lines.should == [2,4]
+    end
   end
-end
 
-describe Duplication, '#examine' do
-  before :each do
-    @mc = MethodContext.new(StopContext.new, s(:defn, :fred))
-    @dup = Duplication.new
+  context "with repeated method calls" do
+    it 'reports repeated call' do
+      src = 'def double_thing() @other.thing + @other.thing end'
+      src.should smell_of(Duplication, Duplication::CALL_KEY => '@other.thing')
+    end
+    it 'reports repeated call to lvar' do
+      src = 'def double_thing(other) other[@thing] + other[@thing] end'
+      src.should smell_of(Duplication, Duplication::CALL_KEY => 'other[@thing]')
+    end
+    it 'reports call parameters' do
+      src = 'def double_thing() @other.thing(2,3) + @other.thing(2,3) end'
+      src.should smell_of(Duplication, Duplication::CALL_KEY => '@other.thing(2, 3)')
+    end
+    it 'should report nested calls' do
+      src = 'def double_thing() @other.thing.foo + @other.thing.foo end'
+      src.should smell_of(Duplication, {Duplication::CALL_KEY => '@other.thing'},
+                                       {Duplication::CALL_KEY => '@other.thing.foo'})
+    end
+    it 'should ignore calls to new' do
+      src = 'def double_thing() @other.new + @other.new end'
+      src.should_not smell_of(Duplication)
+    end
   end
 
-  it 'should return true when reporting a smell' do
-    3.times { @mc.record_call_to(s(:call, nil, :other, s(:arglist)))}
-    @dup.examine(@mc).should == true
-  end
-
-  it 'should return false when not reporting a smell' do
-    @dup.examine(@mc).should == false
+  context 'with repeated attribute assignment' do
+    it 'reports repeated assignment' do
+      src = 'def double_thing(thing) @other[thing] = true; @other[thing] = true; end'
+      src.should smell_of(Duplication, Duplication::CALL_KEY => '@other[thing] = true')
+    end
+    it 'does not report multi-assignments' do
+      src = <<EOS
+def _parse ctxt
+  ctxt.index, result = @ind, @result
+  error, ctxt.index = @err, @err_ind
+end
+EOS
+      src.should_not smell_of(Duplication)
+    end
   end
 
-  it 'should return false when not reporting calls to new' do
-    4.times { @mc.record_call_to(s(:call, s(:Set), :new, s(:arglist)))}
-    @dup.examine(@mc).should == false
+  context "non-repeated method calls" do
+    it 'should not report similar calls' do
+      src = 'def equals(other) other.thing == self.thing end'
+      src.should_not smell_of(Duplication)
+    end
+    it 'should respect call parameters' do
+      src = 'def double_thing() @other.thing(3) + @other.thing(2) end'
+      src.should_not smell_of(Duplication)
+    end
   end
-end
 
-describe Duplication, 'when disabled' do
-  before :each do
-    @ctx = MethodContext.new(StopContext.new, [0, :double_thing])
-    @dup = Duplication.new({SmellConfiguration::ENABLED_KEY => false})
+  context "allowing up to 3 calls" do
+    before :each do
+      @config = {Duplication::MAX_ALLOWED_CALLS_KEY => 3}
+    end
+    it 'does not report double calls' do
+      src = 'def double_thing() @other.thing + @other.thing end'
+      src.should_not smell_of(Duplication).with_config(@config)
+    end
+    it 'does not report triple calls' do
+      src = 'def double_thing() @other.thing + @other.thing + @other.thing end'
+      src.should_not smell_of(Duplication).with_config(@config)
+    end
+    it 'reports quadruple calls' do
+      src = 'def double_thing() @other.thing + @other.thing + @other.thing + @other.thing end'
+      src.should smell_of(Duplication, {Duplication::CALL_KEY => '@other.thing', Duplication::OCCURRENCES_KEY => 4}).with_config(@config)
+    end
   end
 
-  it 'should not report repeated call' do
-    @ctx.record_call_to([:fred])
-    @ctx.record_call_to([:fred])
-    @dup.examine(@ctx).should == false
+  context "allowing calls to some methods" do
+    before :each do
+      @config = {Duplication::ALLOW_CALLS_KEY => ['@some.thing',/puts/]}
+    end
+    it 'does not report calls to some methods' do
+      src = 'def double_some_thing() @some.thing + @some.thing end'
+      src.should_not smell_of(Duplication).with_config(@config)
+    end
+    it 'reports calls to other methods' do
+      src = 'def double_other_thing() @other.thing + @other.thing end'
+      src.should smell_of(Duplication, {Duplication::CALL_KEY => '@other.thing'}).with_config(@config)
+    end
+    it 'does not report calls to methods specifed with a regular expression' do
+      src = 'def double_puts() puts @other.thing; puts @other.thing end'
+      src.should smell_of(Duplication, {Duplication::CALL_KEY => '@other.thing'}).with_config(@config)
+    end
   end
 end

data/spec/reek/smells/feature_envy_spec.rb

@@ -1,34 +1,76 @@
-require File.dirname(__FILE__) + '/../../spec_helper.rb'
-require 'reek/smells/feature_envy'
-require 'reek/method_context'
-require 'reek/stop_context'
+require File.join(File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__)))), 'spec_helper')
+require File.join(File.dirname(File.dirname(File.dirname(File.dirname(File.expand_path(__FILE__))))), 'lib', 'reek', 'smells', 'feature_envy')
+require File.join(File.dirname(File.expand_path(__FILE__)), 'smell_detector_shared')
 
 include Reek
 include Reek::Smells
 
 describe FeatureEnvy do
-  it 'should not report use of self' do
-    'def simple() self.to_s + self.to_i end'.should_not reek
+  context 'with no smell' do
+    it 'should not report use of self' do
+      'def simple() self.to_s + self.to_i end'.should_not reek
+    end
+    it 'should not report vcall with no argument' do
+      'def simple() func; end'.should_not reek
+    end
+    it 'should not report vcall with argument' do
+      'def simple(arga) func(17); end'.should_not reek
+    end
+    it 'should not report single use' do
+      'def no_envy(arga) arga.barg(@item) end'.should_not reek
+    end
+    it 'should not report return value' do
+      'def no_envy(arga) arga.barg(@item); arga end'.should_not reek
+    end
+    it 'should ignore global variables' do
+      'def no_envy() $s2.to_a; $s2[@item] end'.should_not reek
+    end
+    it 'should not report class methods' do
+      'def simple() self.class.new.flatten_merge(self) end'.should_not reek
+    end
+    it 'should not report single use of an ivar' do
+      'def no_envy() @item.to_a end'.should_not reek
+    end
+    it 'should not report returning an ivar' do
+      'def no_envy() @item.to_a; @item end'.should_not reek
+    end
+    it 'should not report ivar usage in a parameter' do
+      'def no_envy() @item.price + tax(@item) - savings(@item) end'.should_not reek
+    end
+    it 'should not report single use of an lvar' do
+      'def no_envy() lv = @item; lv.to_a end'.should_not reek
+    end
+    it 'should not report returning an lvar' do
+      'def no_envy() lv = @item; lv.to_a; lv end'.should_not reek
+    end
+    it 'ignores lvar usage in a parameter' do
+      'def no_envy() lv = @item; lv.price + tax(lv) - savings(lv); end'.should_not reek
+    end
+    it 'ignores multiple ivars' do
+      src = <<EOS
+  def func
+    @other.a
+    @other.b
+    @nother.c
+    @nother.d
   end
-
-  it 'should not report vcall with no argument' do
-    'def simple() func; end'.should_not reek
-  end
-
-  it 'should not report vcall with argument' do
-    'def simple(arga) func(17); end'.should_not reek
-  end
-
-  it 'should not report single use' do
-    'def no_envy(arga) arga.barg(@item) end'.should_not reek
-  end
-
-  it 'should not report return value' do
-    'def no_envy(arga) arga.barg(@item); arga end'.should_not reek
+EOS
+      src.should_not reek
+      #
+      # def other.func(me)
+      #   a
+      #   b
+      #   me.nother_c
+      #   me.nother_d
+      # end
+      #
+    end
   end
 
-  it 'should report many calls to parameter' do
-    'def envy(arga) arga.b(arga) + arga.c(@fred) end'.should reek_only_of(:FeatureEnvy, /arga/)
+  context 'with 2 calls to a parameter' do
+    it 'reports the smell' do
+      'def envy(arga) arga.b(arga) + arga.c(@fred) end'.should reek_only_of(:FeatureEnvy, /arga/)
+    end
   end
 
   it 'should report highest affinity' do
@@ -57,26 +99,6 @@ EOS
     src.should reek_of(:FeatureEnvy, /fred/)
   end
 
-  it 'should ignore global variables' do
-    'def no_envy() $s2.to_a; $s2[@item] end'.should_not reek
-  end
-
-  it 'should not report class methods' do
-    'def simple() self.class.new.flatten_merge(self) end'.should_not reek
-  end
-
-  it 'should not report single use of an ivar' do
-    'def no_envy() @item.to_a end'.should_not reek
-  end
-
-  it 'should not report returning an ivar' do
-    'def no_envy() @item.to_a; @item end'.should_not reek
-  end
-
-  it 'should not report ivar usage in a parameter' do
-    'def no_envy() @item.price + tax(@item) - savings(@item) end'.should_not reek
-  end
-
   it 'should not be fooled by duplication' do
     'def feed(thing) @cow.feed_to(thing.pig); @duck.feed_to(thing.pig) end'.should reek_only_of(:Duplication, /thing.pig/)
   end
@@ -85,14 +107,6 @@ EOS
     'def feed(thing) cow.feed_to(thing.pig); duck.feed_to(thing.pig) end'.should reek_only_of(:Duplication, /thing.pig/)
   end
 
-  it 'should not report single use of an lvar' do
-    'def no_envy() lv = @item; lv.to_a end'.should_not reek
-  end
-
-  it 'should not report returning an lvar' do
-    'def no_envy() lv = @item; lv.to_a; lv end'.should_not reek
-  end
-
   it 'should report many calls to lvar' do
     'def envy() lv = @item; lv.price + lv.tax; end'.should reek_only_of(:FeatureEnvy, /lv/)
     #
@@ -105,30 +119,6 @@ EOS
     # end
   end
 
-  it 'ignores lvar usage in a parameter' do
-    'def no_envy() lv = @item; lv.price + tax(lv) - savings(lv); end'.should_not reek
-  end
-
-  it 'ignores multiple ivars' do
-    src = <<EOS
-def func
-  @other.a
-  @other.b
-  @nother.c
-  @nother.d
-end
-EOS
-    src.should_not reek
-    #
-    # def other.func(me)
-    #   a
-    #   b
-    #   me.nother_c
-    #   me.nother_d
-    # end
-    #
-  end
-
   it 'ignores frequent use of a call' do
     'def func() other.a; other.b; nother.c end'.should_not reek_of(:FeatureEnvy)
   end
@@ -166,8 +156,8 @@ EOS
   it 'interprets << correctly' do
     ruby = <<EOS
 def report_on(report)
-  if @is_masked
-    report.record_masked_smell(self)
+  if @is_doubled
+    report.record_doubled_smell(self)
   else
     report << self
   end
@@ -178,20 +168,51 @@ EOS
   end
 end
 
-describe FeatureEnvy, '#examine' do
-
-  before :each do
-    @context = MethodContext.new(StopContext.new, s(:defn, :cool))
-    @fe = FeatureEnvy.new
-  end
-
-  it 'should return true when reporting a smell' do
-    @context.refs.record_ref([:lvar, :thing])
-    @context.refs.record_ref([:lvar, :thing])
-    @fe.examine(@context).should == true
-  end
-
-  it 'should return false when not reporting a smell' do
-    @fe.examine(@context).should == false
+describe FeatureEnvy do
+  before(:each) do
+    @source_name = 'green as a cucumber'
+    @detector = FeatureEnvy.new(@source_name)
+  end
+
+  it_should_behave_like 'SmellDetector'
+
+  context 'when reporting yaml' do
+    before :each do
+      @receiver = 'other'
+      src = <<EOS
+def envious(other)
+  #{@receiver}.call
+  self.do_nothing
+  #{@receiver}.other
+  #{@receiver}.fred
+end
+EOS
+      source = src.to_reek_source
+      sniffer = Sniffer.new(source)
+      @mctx = CodeParser.new(sniffer).process_defn(source.syntax_tree)
+      @smells = @detector.examine_context(@mctx)
+    end
+    it 'reports only that smell' do
+      @smells.length.should == 1
+    end
+    it 'reports the source' do
+      @smells[0].source.should == @source_name
+    end
+    it 'reports the class' do
+      @smells[0].smell_class.should == FeatureEnvy::SMELL_CLASS
+    end
+    it 'reports the subclass' do
+      @smells[0].subclass.should == FeatureEnvy::SMELL_SUBCLASS
+    end
+    it 'reports the envious receiver' do
+      @smells[0].smell[FeatureEnvy::RECEIVER_KEY].should == @receiver
+    end
+    it 'reports the number of references' do
+      @smells[0].smell[FeatureEnvy::REFERENCES_KEY].should == 3
+    end
+    it 'reports the referring lines' do
+      pending
+      @smells[0].lines.should == [2, 4, 5]
+    end
   end
 end