yardstick 0.9.6 → 0.9.7

data/spec/unit/yardstick/ordered_set/length_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Yardstick::OrderedSet, 'length' do
+  subject { described_class.new(items).length }
+
+  let(:items) { [double('item'), double('item')] }
+
+  it { should be(2) }
+end

data/spec/unit/yardstick/ordered_set/merge_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Yardstick::OrderedSet, '#merge' do
+  subject { set.merge(other) }
+
+  let(:set)   { described_class.new([item1]) }
+  let(:other) { described_class.new([item2]) }
+  let(:item1) { double('item')               }
+  let(:item2) { double('item')               }
+
+  it { should be(set) }
+
+  it { should include(item1, item2) }
+end

data/spec/unit/yardstick/parser/class_methods/parse_paths_spec.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Yardstick::Parser, '.parse_paths' do
+  subject(:document_set) { described_class.parse_paths(paths) }
+
+  let(:paths)         { double('paths')                                       }
+  let(:method_object) { double(file: 'foo.rb', line: 4, docstring: docstring) }
+  let(:docstring)     { double('docstring')                                   }
+
+  before do
+    YARD.should_receive(:parse).with(paths, [], YARD::Logger::ERROR)
+    YARD::Registry.stub(:all).with(:method).and_return([method_object])
+  end
+
+  it { should be_a(Yardstick::DocumentSet) }
+
+  its(:length) { should be(1) }
+
+  context 'first document' do
+    subject { document_set.first }
+
+    it { should be_a(Yardstick::Document) }
+
+    its(:docstring) { should eq(docstring) }
+  end
+end

data/spec/unit/yardstick/parser/class_methods/parse_string_spec.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Yardstick::Parser, '.parse_string' do
+  subject(:document_set) { described_class.parse_string(string) }
+
+  let(:string)        { double('string', to_str: 'body')                      }
+  let(:method_object) { double(file: 'foo.rb', line: 4, docstring: docstring) }
+  let(:docstring)     { double('docstring')                                   }
+
+  before do
+    YARD.should_receive(:parse_string).with('body')
+    YARD::Registry.stub(:all).with(:method).and_return([method_object])
+  end
+
+  it { should be_a(Yardstick::DocumentSet) }
+
+  its(:length) { should be(1) }
+
+  context 'first document' do
+    subject { document_set.first }
+
+    it { should be_a(Yardstick::Document) }
+
+    its(:docstring) { should eq(docstring) }
+  end
+end

data/spec/unit/yardstick/processor/process_spec.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Yardstick::Processor, '#process' do
+  subject { described_class.new(config).process }
+
+  let(:config)    { double('config', path: path) }
+  let(:path)      { Pathname('foo/bar.rb')       }
+  let(:documents) { double('document set')       }
+
+  it 'measures files specified in the config' do
+    Yardstick::Parser.should_receive(:parse_paths).with(['foo/bar.rb']) { documents }
+    documents.should_receive(:measure).with(config)
+    subject
+  end
+end

data/spec/unit/yardstick/processor/process_string_spec.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Yardstick::Processor, '#process_string' do
+  subject { described_class.new(config).process_string(string) }
+
+  let(:config)    { double('config')       }
+  let(:string)    { double('string')       }
+  let(:documents) { double('document set') }
+
+  it 'measures specified string' do
+    Yardstick::Parser.should_receive(:parse_string).with(string) { documents }
+    documents.should_receive(:measure).with(config)
+    subject
+  end
+end

data/spec/unit/yardstick/rake/measurement/initialize_spec.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'yardstick/rake/measurement'
+
+describe Yardstick::Rake::Measurement, '#initialize' do
+  context 'with custom arguments' do
+    subject(:task) { described_class.new(:measure, options) }
+
+    let(:config)  { Yardstick::Config.new }
+    let(:options) { double('options')     }
+
+    before do
+      Yardstick::Config.stub(:coerce).with(options) { config }
+    end
+
+    context 'when valid options' do
+      it { should be_a(described_class) }
+
+      it 'creates rake task with given name' do
+        subject
+        expect(Rake::Task['measure']).to be_kind_of(Rake::Task)
+      end
+
+      it 'calls yardstick_measure when rake task is executed' do
+        subject
+        task.should_receive(:yardstick_measure)
+        Rake::Task['measure'].execute
+      end
+
+      it 'should include the threshold in the task name' do
+        task
+        expect(Rake.application.last_description)
+          .to eql('Measure docs in lib/**/*.rb with yardstick')
+      end
+    end
+  end
+
+  context 'when with default arguments' do
+    subject { described_class.new }
+
+    it { should be_a(described_class) }
+
+    it 'assigns yardstick_measure as the name' do
+      subject
+      expect(Rake::Task['yardstick_measure']).to be_kind_of(Rake::Task)
+    end
+  end
+
+  context 'when block provided' do
+    subject(:task) do
+      described_class.new do |config|
+        @yield = config
+      end
+    end
+
+    it { should be_a(described_class) }
+
+    it 'should yield to Config' do
+      task
+      expect(@yield).to be_instance_of(Yardstick::Config)
+    end
+  end
+end

data/spec/unit/yardstick/rake/measurement/yardstick_measure_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'yardstick/rake/measurement'
+
+describe Yardstick::Rake::Measurement, '#yardstick_measure' do
+  subject { described_class.new(:yardstick_measure, options).yardstick_measure }
+
+  let(:config)        { double('config', path: 'tmp', output: report_writer) }
+  let(:report_writer) { double('report writer')                              }
+  let(:options)       { double('options')                                    }
+  let(:measurements)  { double('measurements')                               }
+  let(:io)            { double('io')                                         }
+
+  it 'writes yardstick results' do
+    Yardstick::Config.stub(:coerce).with(options) { config }
+    Yardstick.stub(:measure).with(config) { measurements }
+    report_writer.stub(:write).and_yield(io)
+    measurements.should_receive(:puts).with(io)
+    subject
+  end
+end

data/spec/unit/yardstick/rake/verify/initialize_spec.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'yardstick/rake/verify'
+
+describe Yardstick::Rake::Verify, '#initialize' do
+  context 'with custom arguments' do
+    subject(:task) { described_class.new(:verify, options) }
+
+    let(:config)  { Yardstick::Config.new(threshold: 90) }
+    let(:options) { double('options')                    }
+
+    before do
+      Yardstick::Config.stub(:coerce).with(options) { config }
+    end
+
+    context 'when valid options' do
+      it { should be_a(described_class) }
+
+      it 'creates rake task with given name' do
+        subject
+        expect(Rake::Task['verify']).to be_kind_of(Rake::Task)
+      end
+
+      it 'calls verify_measurements when rake task is executed' do
+        subject
+        task.should_receive(:verify_measurements)
+        Rake::Task['verify'].execute
+      end
+
+      it 'should include the threshold in the task name' do
+        task
+        expect(Rake.application.last_description)
+          .to eql('Verify that yardstick coverage is at least 90%')
+      end
+    end
+
+    context 'when threshold is not specified' do
+      before { config.threshold = nil }
+
+      it 'raises error' do
+        expect { task }.to raise_error(RuntimeError, 'threshold must be set')
+      end
+    end
+  end
+
+  context 'when with default arguments' do
+    subject { described_class.new }
+
+    it { should be_a(described_class) }
+
+    it 'assigns verify_measurements as the name' do
+      subject
+      expect(Rake::Task['verify_measurements']).to be_kind_of(Rake::Task)
+    end
+  end
+
+  context 'when block provided' do
+    subject(:task) do
+      described_class.new do |config|
+        @yield = config
+      end
+    end
+
+    it { should be_a(described_class) }
+
+    it 'should yield to Config' do
+      task
+      expect(@yield).to be_instance_of(Yardstick::Config)
+    end
+  end
+end

data/spec/unit/yardstick/rake/verify/verify_measurements_spec.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'yardstick/rake/verify'
+
+describe Yardstick::Rake::Verify, '#verify_measurements' do
+  subject(:measure) do
+    capture_stdout { described_class.new(:verify, options).verify_measurements }
+  end
+
+  let(:config)  { Yardstick::Config.new(threshold: 90) }
+  let(:options) { double('options')                    }
+
+  before do
+    Yardstick::Config.stub(:coerce).with(options) { config }
+    Yardstick.stub(:measure).with(config) { measurements }
+  end
+
+  context 'when verbose' do
+    let(:measurements) { double('measurements', coverage: 0.9) }
+
+    it 'outputs coverage' do
+      measure
+      expect(@output).to eq("YARD-Coverage: 90.0% (threshold: 90%)\n")
+    end
+  end
+
+  context 'when not verbose' do
+    let(:measurements) { double('measurements', coverage: 0.9) }
+
+    before do
+      config.verbose = false
+    end
+
+    it 'outputs nothing' do
+      measure
+      expect(@output).to eq('')
+    end
+  end
+
+  context 'when lower coverage' do
+    let(:measurements) { double('measurements', coverage: 0.434) }
+
+    it 'outputs coverage' do
+      expect { measure }.to raise_error
+      expect(@output).to eq("YARD-Coverage: 43.4% (threshold: 90%)\n")
+    end
+
+    it 'raises error about low coverage' do
+      expect { measure }
+        .to raise_error(RuntimeError, 'YARD-Coverage must be at least 90% but was 43.4%')
+    end
+  end
+
+  context 'when higher coverage' do
+    let(:measurements) { double('measurements', coverage: 0.9989) }
+
+    it 'outputs coverage' do
+      expect { measure }.to raise_error
+      expect(@output).to eq("YARD-Coverage: 99.8% (threshold: 90%)\n")
+    end
+
+    it 'raises error about high coverage' do
+      expect { measure }
+        .to raise_error(RuntimeError, 'YARD-Coverage has increased above the threshold of 90% to 99.8%. You should update your threshold value.')
+    end
+  end
+
+  context 'when higher coverage without exact threshold requirement' do
+    let(:measurements) { double('measurements', coverage: 1) }
+
+    before do
+      config.require_exact_threshold = false
+    end
+
+    it 'outputs coverage' do
+      measure
+      expect(@output).to eq("YARD-Coverage: 100.0% (threshold: 90%)\n")
+    end
+
+    it 'passes' do
+      expect { measure }.to_not raise_error
+    end
+  end
+end

data/spec/unit/yardstick/report_output/class_methods/coerce_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Yardstick::ReportOutput, '.coerce' do
+  subject { described_class.coerce(target) }
+
+  let(:target) { '/foo/bar.rb' }
+
+  it { should be_a(described_class) }
+
+  its(:to_s) { should eq(target) }
+
+  it 'coerces target to Pathname' do
+    target = subject.instance_variable_get(:@target)
+    expect(target).to be_a(Pathname)
+  end
+end

data/spec/unit/yardstick/report_output/initialize_spec.rb

@@ -0,0 +1,11 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Yardstick::ReportOutput, '#initialize' do
+  subject { described_class.new(target) }
+
+  let(:target) { Pathname('/foo/bar') }
+
+  it { should be_instance_of(described_class) }
+end

data/spec/unit/yardstick/report_output/to_s_spec.rb

@@ -0,0 +1,12 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Yardstick::ReportOutput, '#to_s' do
+  subject { described_class.new(pathname).to_s }
+
+  let(:pathname) { Pathname(path) }
+  let(:path)     { '/foo/bar'     }
+
+  it { should == path }
+end

data/spec/unit/yardstick/report_output/write_spec.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Yardstick::ReportOutput, 'write' do
+  subject do
+    described_class.new(target).write do |io|
+      io.puts 'content'
+    end
+  end
+
+  let(:target)  { double('Pathname', dirname: dirname) }
+  let(:dirname) { double                               }
+
+  before do
+    dirname.stub(:mkpath)
+    target.stub(:open)
+  end
+
+  it 'should create directory' do
+    dirname.should_receive(:mkpath)
+    subject
+  end
+
+  it 'should write content' do
+    io = double
+    io.should_receive(:puts).with('content')
+    target.should_receive(:open).with('w').and_yield(io)
+    subject
+  end
+end