rake-funnel 0.0.1.pre

data/spec/rake/funnel/integration/sync_output_spec.rb

@@ -0,0 +1,16 @@
+describe Rake::Funnel::Integration::SyncOutput do
+  before {
+    allow($stdout).to receive(:sync=)
+    allow($stderr).to receive(:sync=)
+
+    expect(subject).to be
+  }
+
+  it 'should immediately flush stdout' do
+    expect($stdout).to have_received(:sync=).with(true)
+  end
+
+  it 'should immediately flush stderr' do
+    expect($stdout).to have_received(:sync=).with(true)
+  end
+end

data/spec/rake/funnel/integration/teamcity/nunit_plugin_spec.rb

@@ -0,0 +1,112 @@
+include Rake::Funnel::Support
+
+describe Rake::Funnel::Integration::TeamCity::NUnitPlugin do
+  let(:env_var) { nil }
+  let(:which) { nil }
+  let(:nunit_exe_contents) { nil }
+
+  before {
+    allow(ENV).to receive(:[]).with(described_class::ENV_VAR).and_return(env_var)
+    allow(Which).to receive(:which).and_return(which)
+    allow(File).to receive(:read).with(which).and_return(nunit_exe_contents)
+    allow(Dir).to receive(:glob).and_return([])
+    allow(RakeFileUtils).to receive(:mkdir_p)
+    allow(Rake).to receive(:rake_output_message)
+  }
+
+  def binary_version(*version_parts)
+    version = version_parts.map { |p| p.to_s + "\0" }.join(".\0")
+    "F\0i\0l\0e\0V\0e\0r\0s\0i\0o\0n" + "\0" * 3 + version + "\0" * 3
+  end
+
+  describe 'success' do
+    let(:env_var) { '/path/to/nunit plugins/nunit' }
+    let(:addin_dlls) { [env_var + 'addin.dll'] }
+    let(:which) { 'path/to/nunit-console.exe' }
+    let(:nunit_exe_contents) { "binary #{binary_version(1, 2, 3, 4)} binary" }
+
+    before {
+      allow(Dir).to receive(:glob).and_return(addin_dlls)
+      allow(RakeFileUtils).to receive(:cp)
+    }
+
+    before {
+      described_class.setup('nunit-console.exe')
+    }
+
+    it 'should create addin directory' do
+      expect(RakeFileUtils).to have_received(:mkdir_p).with(File.join(File.dirname(which), 'addins'))
+    end
+
+    it 'should enumerate addin files' do
+      expect(Dir).to have_received(:glob).with(/#{Regexp.escape(env_var + '-1.2.3.*')}$/)
+    end
+
+    it 'should copy the addin from TeamCity to NUnit' do
+      expect(RakeFileUtils).to have_received(:cp).with(addin_dlls, File.join(File.dirname(which), 'addins'))
+    end
+
+    it 'should report that the addin is installed' do
+      expect(Rake).to have_received(:rake_output_message).with("Installing TeamCity NUnit addin for version 1.2.3 in #{which}")
+    end
+
+    context 'Windows-style path in environment variable', platform: :win32 do
+      let(:env_var) { 'C:\path\to\nunit plugins\nunit-' }
+
+      it 'should convert path to Ruby-style' do
+        expect(Dir).to have_received(:glob).with(%r|^C:/path/to/nunit plugins/nunit-|)
+      end
+    end
+  end
+
+  describe 'failures' do
+    before {
+      described_class.setup('nunit-console.exe')
+    }
+
+    context 'TeamCity plugin path not in environment' do
+      let(:env_var) { nil }
+
+      it 'should skip' do
+        expect(File).to_not have_received(:read)
+      end
+    end
+
+    context 'NUnit executable not found' do
+      let(:env_var) { '/path/to/nunit plugins/nunit' }
+      let(:which) { nil }
+
+      it 'should skip' do
+        expect(File).to_not have_received(:read)
+      end
+    end
+
+    context 'NUnit executable without version' do
+      let(:env_var) { '/path/to/nunit plugins/nunit' }
+      let(:which) { 'path/to/nunit-console.exe' }
+      let(:nunit_exe_contents) { 'version number not available ' }
+
+      it 'should report that the version could not be read' do
+        expect(Rake).to have_received(:rake_output_message).with("Could read version from NUnit executable in #{which}")
+      end
+
+      it 'should skip' do
+        expect(Dir).not_to have_received(:glob)
+      end
+    end
+
+    context 'plugin for NUnit version not available' do
+      let(:env_var) { '/path/to/nunit plugins/nunit' }
+      let(:which) { 'path/to/nunit-console.exe' }
+      let(:nunit_exe_contents) { binary_version(1, 2, 3, 4) }
+
+      it 'should report that the addin version is not available' do
+        expect(Rake).to have_received(:rake_output_message).with(/Could not find TeamCity NUnit addin for version 1\.2\.3 in .*#{env_var}$/)
+      end
+
+      it 'should skip' do
+        expect(RakeFileUtils).not_to have_received(:mkdir_p)
+      end
+    end
+  end
+end

data/spec/rake/funnel/integration/teamcity/progress_report_spec.rb

@@ -0,0 +1,174 @@
+include Rake
+include Rake::Funnel::Integration
+include Rake::Funnel::Integration::TeamCity
+
+describe Rake::Funnel::Integration::TeamCity::ProgressReport do
+  include DSL
+
+  let(:teamcity_running?) { false }
+  let(:teamcity_rake_runner?) { false }
+
+  before {
+    allow(TeamCity).to receive(:running?).and_return(teamcity_running?)
+    allow(TeamCity).to receive(:rake_runner?).and_return(teamcity_rake_runner?)
+    allow(ServiceMessages).to receive(:block_opened)
+    allow(ServiceMessages).to receive(:block_closed)
+    allow(ServiceMessages).to receive(:progress_start)
+    allow(ServiceMessages).to receive(:progress_finish)
+    allow(ServiceMessages).to receive(:build_problem)
+
+    Task.clear
+  }
+
+  subject! {
+    described_class.new
+  }
+
+  after {
+    subject.disable!
+  }
+
+  shared_examples :block_report do
+    it 'should write block start' do
+      expect(ServiceMessages).to have_received(:block_opened).with(name: 'task')
+    end
+
+    it 'should write block end' do
+      expect(ServiceMessages).to have_received(:block_closed).with(name: 'task')
+    end
+  end
+
+  shared_examples :no_block_report do
+    it 'should not write block start' do
+      expect(ServiceMessages).not_to have_received(:block_opened)
+    end
+
+    it 'should not write block end' do
+      expect(ServiceMessages).not_to have_received(:block_closed)
+    end
+  end
+
+  context 'when task succeeds' do
+    before {
+      task :task
+
+      Task[:task].invoke
+    }
+
+    it 'should not report build problems' do
+      expect(ServiceMessages).to_not have_received(:build_problem)
+    end
+
+    context 'not on TeamCity' do
+      it_behaves_like :no_block_report
+    end
+
+    context 'on TeamCity' do
+      let(:teamcity_running?) { true }
+
+      context 'without rake runner' do
+        it_behaves_like :block_report
+      end
+
+      context 'with rake runner' do
+        let(:teamcity_rake_runner?) { true }
+
+        it_behaves_like :no_block_report
+      end
+    end
+  end
+
+  context 'when task fails' do
+    class SpecificError < StandardError; end
+
+    before {
+      module Rake
+        class ApplicationAbortedException < StandardError
+          attr_reader :inner_exception
+
+          def initialize(other_exception)
+            @inner_exception = other_exception
+          end
+        end
+      end
+    }
+
+    let(:error) { SpecificError.new('task error' * 4000) }
+
+    before {
+      task :task do
+        raise error
+      end
+
+      begin
+        Task[:task].invoke
+      rescue ApplicationAbortedException => e
+      rescue SpecificError => e
+        @raised_error = e
+      end
+    }
+
+    context 'not on TeamCity' do
+      it_behaves_like :no_block_report
+
+      it 'should not swallow the error' do
+        expect(@raised_error).to be_a_kind_of(SpecificError)
+      end
+    end
+
+    context 'on TeamCity' do
+      let(:teamcity_running?) { true }
+
+      describe 'build problems' do
+        it 'should report build problems' do
+          expect(ServiceMessages).to have_received(:build_problem)
+        end
+
+        it 'should report the error message' do
+          expect(ServiceMessages).to have_received(:build_problem).with(hash_including({ description: be_an_instance_of(String) }))
+        end
+
+        it 'should report the first 4000 characters of the error message' do
+          expect(ServiceMessages).to have_received(:build_problem).with(hash_including({ description: have(4000).items }))
+        end
+      end
+
+      context 'without rake runner' do
+        it_behaves_like :block_report
+
+        it 'should report the error as a build problem' do
+          expect(ServiceMessages).to have_received(:build_problem)
+        end
+      end
+
+      context 'with rake runner' do
+        let(:teamcity_rake_runner?) { true }
+        let(:error) {
+          ApplicationAbortedException.new(SpecificError.new('inner message'))
+        }
+
+        it 'should report the inner error as a build problem (as it will be wrapped in a ApplicationAbortedException)' do
+          expect(ServiceMessages).to have_received(:build_problem).with({ description: 'inner message' })
+        end
+
+        it_behaves_like :no_block_report
+      end
+    end
+  end
+
+  context 'when progess report was disabled' do
+    let(:teamcity_running?) { true }
+
+    before {
+      subject.disable!
+
+      task :task
+
+      Task[:task].invoke
+    }
+
+    it 'should not write' do
+      expect(ServiceMessages).to_not have_received(:block_opened)
+    end
+  end
+end

data/spec/rake/funnel/integration/teamcity/service_messages_spec.rb

@@ -0,0 +1,136 @@
+include Rake::Funnel::Integration
+
+describe Rake::Funnel::Integration::TeamCity::ServiceMessages do
+  before {
+    allow(TeamCity).to receive(:running?).and_return(teamcity_running?)
+    allow($stdout).to receive(:puts)
+  }
+
+  context 'when running outside TeamCity' do
+    let(:teamcity_running?) { false }
+
+    it 'should not publish messages' do
+      described_class.progress_start 'foo'
+
+      expect($stdout).not_to have_received(:puts)
+    end
+  end
+
+  context 'when running inside TeamCity' do
+    let(:teamcity_running?) { true }
+
+    describe 'escaping' do
+      context 'when publishing messages without special characters' do
+        it 'should not escape' do
+          described_class.progress_start "the message"
+
+          expect($stdout).to have_received(:puts).with("##teamcity[progressStart 'the message']")
+        end
+      end
+
+      context 'when publishing messages with special characters' do
+        it 'should escape apostrophes' do
+          described_class.progress_start "'"
+
+          expect($stdout).to have_received(:puts).with("##teamcity[progressStart '|'']")
+        end
+
+        it 'should escape line feeds' do
+          described_class.progress_start "\n"
+
+          expect($stdout).to have_received(:puts).with("##teamcity[progressStart '|n']")
+        end
+
+        it 'should escape carriage returns' do
+          described_class.progress_start "\r"
+
+          expect($stdout).to have_received(:puts).with("##teamcity[progressStart '|r']")
+        end
+
+        it 'should escape next lines' do
+          described_class.progress_start "\u0085"
+
+          expect($stdout).to have_received(:puts).with("##teamcity[progressStart '|x']")
+        end
+
+        it 'should escape line separators' do
+          described_class.progress_start "\u2028"
+
+          expect($stdout).to have_received(:puts).with("##teamcity[progressStart '|l']")
+        end
+
+        it 'should escape paragraph separators' do
+          described_class.progress_start "\u2029"
+
+          expect($stdout).to have_received(:puts).with("##teamcity[progressStart '|p']")
+        end
+
+        it 'should escape vertical bars' do
+          described_class.progress_start '|'
+
+          expect($stdout).to have_received(:puts).with("##teamcity[progressStart '||']")
+        end
+
+        it 'should escape opening brackets' do
+          described_class.progress_start '['
+
+          expect($stdout).to have_received(:puts).with("##teamcity[progressStart '|[']")
+        end
+
+        it 'should escape closing brackets' do
+          described_class.progress_start ']'
+
+          expect($stdout).to have_received(:puts).with("##teamcity[progressStart '|]']")
+        end
+
+        it 'should escape all special characters in a string' do
+          described_class.progress_start "[\r|\n]"
+
+          expect($stdout).to have_received(:puts).with("##teamcity[progressStart '|[|r|||n|]']")
+        end
+      end
+    end
+
+    describe 'parameters' do
+      context 'when reporting a message without parameters' do
+        it 'should print the service message' do
+          described_class.enable_service_messages
+
+          expect($stdout).to have_received(:puts).with('##teamcity[enableServiceMessages]')
+        end
+      end
+
+      context 'when reporting a message with an unnamed parameter' do
+        it 'should print the service message' do
+          described_class.progress_message 'the message'
+
+          expect($stdout).to have_received(:puts).with("##teamcity[progressMessage 'the message']")
+        end
+      end
+
+      context 'when reporting a message with a named parameter' do
+        it 'should print the service message' do
+          described_class.block_opened({ name: 'block name' })
+
+          expect($stdout).to have_received(:puts).with("##teamcity[blockOpened name='block name']")
+        end
+      end
+
+      context 'when reporting a message with multiple named parameters' do
+        it 'should print the service message' do
+          described_class.test_started ({ name: 'test name', captureStandardOutput: true })
+
+          expect($stdout).to have_received(:puts).with("##teamcity[testStarted name='test name' captureStandardOutput='true']")
+        end
+      end
+
+      context 'when reporting a message with Ruby-style named parameters' do
+        it 'should print the service message' do
+          described_class.test_started ({ capture_standard_output: true })
+
+          expect($stdout).to have_received(:puts).with("##teamcity[testStarted captureStandardOutput='true']")
+        end
+      end
+    end
+  end
+end

data/spec/rake/funnel/integration/teamcity/teamcity_spec.rb

@@ -0,0 +1,34 @@
+describe Rake::Funnel::Integration::TeamCity do
+  before {
+    allow(ENV).to receive(:include?).with(described_class::ENV_VAR).and_return(teamcity_running?)
+  }
+
+  context 'when running outside TeamCity' do
+    let(:teamcity_running?) { false }
+
+    it 'should not detect TeamCity' do
+      expect(described_class.running?).to eq(false)
+    end
+
+    it "should not detect TeamCity's rake runner" do
+      expect(described_class.rake_runner?).to eq(false)
+    end
+  end
+
+  context 'when running inside TeamCity' do
+    let(:teamcity_running?) { true }
+
+    it 'should detect TeamCity' do
+      expect(described_class.running?).to eq(true)
+    end
+
+    it "should detect TeamCity's rake runner" do
+      module ::Rake
+        module TeamCityApplication
+        end
+      end
+
+      expect(described_class.rake_runner?).to eq(true)
+    end
+  end
+end

data/spec/rake/funnel/support/finder_spec.rb

@@ -0,0 +1,210 @@
+include Rake::Funnel
+
+describe Rake::Funnel::Support::Finder do
+  let(:pattern) { %W(#{temp_dir}/**/*.sln #{temp_dir}/**/*.??proj) }
+  let(:generate) { [] }
+  let(:temp_dir) { Dir.mktmpdir }
+
+  before {
+    Dir.chdir(temp_dir) do
+      ([] << generate).flatten.each do |file|
+        FileUtils.mkdir_p(File.dirname(file))
+        FileUtils.touch(file)
+      end
+    end
+  }
+
+  after {
+    FileUtils.rm_rf(temp_dir)
+  }
+
+  subject {
+    described_class.new(pattern, OpenStruct.new(name: 'task name'), 'error message')
+  }
+
+  def map_temp(*files)
+    mapped = files.map { |f| File.join(temp_dir, f) }
+    return mapped.first if mapped.one?
+    mapped
+  end
+
+  describe 'enumerable' do
+    let(:generate) { %w(1 2 3 4) }
+    let(:pattern) { '**/*' }
+
+    it 'should be enumerable' do
+      expect(described_class < Enumerable).to eq(true)
+      expect(subject.respond_to?(:each)).to eq(true)
+      expect(subject.each).to be_kind_of(Enumerator)
+    end
+
+    it 'should support enumerable methods' do
+      Dir.chdir(temp_dir) do
+        items = subject.map { |x| x }
+        expect(subject.all_or_default).to match_array(items)
+      end
+    end
+  end
+
+  describe 'patterns' do
+    let(:generate) { %w(1 2 3 4) }
+
+    context 'single pattern' do
+      let(:pattern) { '**/*' }
+
+      it 'should yield' do
+        Dir.chdir(temp_dir) do
+          expect(subject.all_or_default).to match_array(generate)
+        end
+      end
+    end
+
+    context 'pattern list' do
+      let(:pattern) { %w(**/*) }
+
+      it 'should yield' do
+        Dir.chdir(temp_dir) do
+          expect(subject.all_or_default).to match_array(generate)
+        end
+      end
+    end
+
+    context 'Rake::FileList' do
+      let(:pattern) { FileList['**/*'] }
+
+      it 'should yield' do
+        Dir.chdir(temp_dir) do
+          expect(subject.all_or_default).to match_array(generate)
+        end
+      end
+    end
+
+    context 'patterns generating multiple matches per file' do
+      let(:pattern) { %w(**/* **/*) }
+
+      it 'should remove duplicates' do
+        Dir.chdir(temp_dir) do
+          expect(subject.all_or_default).to match_array(generate)
+        end
+      end
+    end
+  end
+
+  describe '#single' do
+    context 'no matching files' do
+      it 'should fail' do
+        Dir.chdir(temp_dir) do
+          expect(lambda { subject.single }).to raise_error(AmbiguousFileError, /error message/)
+        end
+      end
+    end
+
+    context 'more than one matching file' do
+      let(:generate) { %w(foo/project1.sln foo/project2.sln) }
+
+      it 'should fail' do
+        Dir.chdir(temp_dir) do
+          expect(lambda { subject.single }).to raise_error(AmbiguousFileError, /error message/)
+        end
+      end
+    end
+
+    context 'one matching file' do
+      let(:generate) { 'foo/project.sln' }
+
+      it 'should yield match' do
+        Dir.chdir(temp_dir) do
+          expect(subject.single).to eq(map_temp(generate))
+        end
+      end
+    end
+  end
+
+  describe '#single_or_default' do
+    context 'no matching files' do
+      it 'should yield nil' do
+        Dir.chdir(temp_dir) do
+          expect(subject.single_or_default).to be_nil
+        end
+      end
+    end
+
+    context 'more than one matching file' do
+      let(:generate) { %w(foo/project1.sln foo/project2.sln) }
+
+      it 'should yield first match' do
+        Dir.chdir(temp_dir) do
+          expect(subject.single_or_default).to be_nil
+        end
+      end
+    end
+
+    context 'one matching file' do
+      let(:generate) { 'foo/project.sln' }
+
+      it 'should yield match' do
+        Dir.chdir(temp_dir) do
+          expect(subject.single_or_default).to eq(map_temp(generate))
+        end
+      end
+    end
+  end
+
+  describe '#all' do
+    context 'no matching files' do
+      it 'should fail' do
+        expect(lambda { subject.all }).to raise_error(AmbiguousFileError, /error message/)
+      end
+    end
+
+    context 'more than one matching file' do
+      let(:generate) { %w(foo/project1.sln foo/project2.sln) }
+
+      it 'should yield all matches' do
+        Dir.chdir(temp_dir) do
+          expect(subject.all).to match_array(map_temp(*generate))
+        end
+      end
+    end
+
+    context 'one matching file' do
+      let(:generate) { 'foo/project.sln' }
+
+      it 'should yield all matches' do
+        Dir.chdir(temp_dir) do
+          expect(subject.all).to match_array(map_temp(generate))
+        end
+      end
+    end
+  end
+
+  describe '#all_or_default' do
+    context 'no matching files' do
+      it 'should be empty' do
+        Dir.chdir(temp_dir) do
+          expect(subject.all_or_default).to be_empty
+        end
+      end
+    end
+
+    context 'more than one matching file' do
+      let(:generate) { %w(foo/project1.sln foo/project2.sln) }
+
+      it 'should yield all matches' do
+        Dir.chdir(temp_dir) do
+          expect(subject.all_or_default).to match_array(map_temp(*generate))
+        end
+      end
+    end
+
+    context 'one matching file' do
+      let(:generate) { 'foo/project.sln' }
+
+      it 'should yield all matches' do
+        Dir.chdir(temp_dir) do
+          expect(subject.all_or_default).to match_array(map_temp(generate))
+        end
+      end
+    end
+  end
+end