rake-funnel 0.3.2.pre → 0.4.0.pre

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

@@ -1,149 +1,149 @@
-include Rake
-include Rake::Funnel::Integration
-
-describe Rake::Funnel::Integration::ProgressReport do
-  include DSL
-
-  let(:teamcity_running?) { false }
-
-  before {
-    allow($stdout).to receive(:puts)
-    allow(TeamCity).to receive(:running?).and_return(teamcity_running?)
-
-    Task.clear
-  }
-
-  after {
-    subject.disable!
-  }
-
-  describe 'defaults' do
-    subject! {
-      described_class.new
-    }
-
-    before {
-      task :task
-
-      Task[:task].invoke
-    }
-
-    context 'not on TeamCity' do
-      it 'should write task name in square brackets' do
-        expect($stdout).to have_received(:puts).with("\n[task]")
-      end
-    end
-
-    context 'on TeamCity' do
-      let(:teamcity_running?) { true }
-
-      it 'should not write task name in square brackets since it would clutter the output' do
-        expect($stdout).to_not have_received(:puts).with("\n[task]")
-      end
-    end
-  end
-
-  context 'when progess report was disabled' do
-    subject! {
-      described_class.new
-    }
-
-    before {
-      subject.disable!
-
-      task :task
-
-      Task[:task].invoke
-    }
-
-    it 'should not write' do
-      expect($stdout).to_not have_received(:puts).with("\n[task]")
-    end
-  end
-
-  describe 'custom event handlers' do
-    let(:receiver) { double.as_null_object }
-
-    subject! {
-      described_class.new do |r|
-        r.task_starting do |task, args|
-          receiver.starting({
-            task: task,
-            args: args
-          })
-        end
-
-        r.task_finished do |task, args, error|
-          receiver.finished({
-            task: task,
-            args: args,
-            error: error
-          })
-        end
-      end
-    }
-
-    context 'when task succeeds' do
-      before {
-        task :task
-
-        Task[:task].invoke
-      }
-
-      describe 'starting handler' do
-        it 'should run' do
-          expect(receiver).to have_received(:starting)
-        end
-
-        it 'should receive task' do
-          expect(receiver).to have_received(:starting).with(hash_including({ task: kind_of(Task) }))
-        end
-
-        it 'should receive task arguments' do
-          expect(receiver).to have_received(:starting).with(hash_including({ args: kind_of(TaskArguments) }))
-        end
-      end
-
-      describe 'finished handler' do
-        it 'should run' do
-          expect(receiver).to have_received(:finished)
-        end
-
-        it 'should receive task' do
-          expect(receiver).to have_received(:finished).with(hash_including({ task: kind_of(Task) }))
-        end
-
-        it 'should receive task arguments' do
-          expect(receiver).to have_received(:finished).with(hash_including({ args: kind_of(TaskArguments) }))
-        end
-
-        it 'should not receive error' do
-          expect(receiver).to have_received(:finished).with(hash_including({ error: nil }))
-        end
-      end
-    end
-
-    context 'when task fails' do
-      class SpecificError < StandardError;  end
-
-      let(:error) { SpecificError.new('task error') }
-
-      before {
-        task :task do
-          raise error
-        end
-
-        begin
-          Task[:task].invoke
-        rescue SpecificError
-        end
-      }
-
-      describe 'finished handler' do
-        it 'should receive error' do
-          expect(receiver).to have_received(:finished).with(hash_including({ error: error }))
-        end
-      end
-    end
-  end
-end
+include Rake
+include Rake::Funnel::Integration
+
+describe Rake::Funnel::Integration::ProgressReport do
+  include DSL
+
+  let(:teamcity_running?) { false }
+
+  before {
+    allow($stdout).to receive(:puts)
+    allow(TeamCity).to receive(:running?).and_return(teamcity_running?)
+
+    Task.clear
+  }
+
+  after {
+    subject.disable!
+  }
+
+  describe 'defaults' do
+    subject! {
+      described_class.new
+    }
+
+    before {
+      task :task
+
+      Task[:task].invoke
+    }
+
+    context 'not on TeamCity' do
+      it 'should write task name in square brackets' do
+        expect($stdout).to have_received(:puts).with("\n[task]")
+      end
+    end
+
+    context 'on TeamCity' do
+      let(:teamcity_running?) { true }
+
+      it 'should not write task name in square brackets since it would clutter the output' do
+        expect($stdout).to_not have_received(:puts).with("\n[task]")
+      end
+    end
+  end
+
+  context 'when progess report was disabled' do
+    subject {
+      described_class.new
+    }
+
+    before {
+      subject.disable!
+
+      task :task
+
+      Task[:task].invoke
+    }
+
+    it 'should not write' do
+      expect($stdout).to_not have_received(:puts).with("\n[task]")
+    end
+  end
+
+  describe 'custom event handlers' do
+    let(:receiver) { double.as_null_object }
+
+    subject! {
+      described_class.new do |r|
+        r.task_starting do |task, args|
+          receiver.task_starting({
+            task: task,
+            args: args
+          })
+        end
+
+        r.task_finished do |task, args, error|
+          receiver.task_finished({
+            task: task,
+            args: args,
+            error: error
+          })
+        end
+      end
+    }
+
+    context 'when task succeeds' do
+      before {
+        task :task
+
+        Task[:task].invoke
+      }
+
+      describe 'starting handler' do
+        it 'should run' do
+          expect(receiver).to have_received(:task_starting)
+        end
+
+        it 'should receive task' do
+          expect(receiver).to have_received(:task_starting).with(hash_including({ task: kind_of(Task) }))
+        end
+
+        it 'should receive task arguments' do
+          expect(receiver).to have_received(:task_starting).with(hash_including({ args: kind_of(TaskArguments) }))
+        end
+      end
+
+      describe 'finished handler' do
+        it 'should run' do
+          expect(receiver).to have_received(:task_finished)
+        end
+
+        it 'should receive task' do
+          expect(receiver).to have_received(:task_finished).with(hash_including({ task: kind_of(Task) }))
+        end
+
+        it 'should receive task arguments' do
+          expect(receiver).to have_received(:task_finished).with(hash_including({ args: kind_of(TaskArguments) }))
+        end
+
+        it 'should not receive error' do
+          expect(receiver).to have_received(:task_finished).with(hash_including({ error: nil }))
+        end
+      end
+    end
+
+    context 'when task fails' do
+      class SpecificError < StandardError;  end
+
+      let(:error) { SpecificError.new('task error') }
+
+      before {
+        task :task do
+          raise error
+        end
+
+        begin
+          Task[:task].invoke
+        rescue SpecificError
+        end
+      }
+
+      describe 'finished handler' do
+        it 'should receive error' do
+          expect(receiver).to have_received(:task_finished).with(hash_including({ error: error }))
+        end
+      end
+    end
+  end
+end

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

@@ -1,16 +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
+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

@@ -1,110 +1,110 @@
-include Rake::Funnel::Support
-
-describe Rake::Funnel::Integration::TeamCity::NUnitPlugin do
-  before {
-    allow(ENV).to receive(:[]).with(described_class::ENV_VAR).and_return(env_var)
-    allow(Which).to receive(:which).and_return(which)
-    allow(Dir).to receive(:glob).and_return([])
-    allow(RakeFileUtils).to receive(:mkdir_p)
-    allow(Rake).to receive(:rake_output_message)
-  }
-
-  before {
-    allow(BinaryVersionReader).to receive(:read_from).with(which).and_return(nunit_version)
-  }
-
-  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_version) { VersionInfo.new({ file_version: '1.2.3.4' }) }
-    let(:plugin_version) { nunit_version.file_version.split('.').take(3).join('.') }
-
-    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}-#{plugin_version}\.*")}$/)
-    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'), { preserve: true })
-    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 #{plugin_version} 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
-    let(:env_var) { nil }
-    let(:which) { nil }
-    let(:nunit_version) { VersionInfo.new }
-
-    before {
-      described_class.setup('nunit-console.exe')
-    }
-
-    context 'TeamCity plugin path not in environment' do
-      let(:env_var) { nil }
-
-      it 'should skip reading the version' do
-        expect(BinaryVersionReader).to_not have_received(:read_from)
-      end
-    end
-
-    context 'NUnit executable not found' do
-      let(:env_var) { '/path/to/nunit plugins/nunit' }
-      let(:which) { nil }
-
-      it 'should skip reading the version' do
-        expect(BinaryVersionReader).to_not have_received(:read_from)
-      end
-    end
-
-    context 'NUnit executable without version' do
-      let(:env_var) { '/path/to/nunit plugins/nunit' }
-      let(:which) { 'path/to/nunit-console.exe' }
-
-      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_version) { VersionInfo.new({ file_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
+include Rake::Funnel::Support
+
+describe Rake::Funnel::Integration::TeamCity::NUnitPlugin do
+  before {
+    allow(ENV).to receive(:[]).with(described_class::ENV_VAR).and_return(env_var)
+    allow(Which).to receive(:which).and_return(which)
+    allow(Dir).to receive(:glob).and_return([])
+    allow(RakeFileUtils).to receive(:mkdir_p)
+    allow(Rake).to receive(:rake_output_message)
+  }
+
+  before {
+    allow(BinaryVersionReader).to receive(:read_from).with(which).and_return(nunit_version)
+  }
+
+  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_version) { VersionInfo.new({ file_version: '1.2.3.4' }) }
+    let(:plugin_version) { nunit_version.file_version.split('.').take(3).join('.') }
+
+    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}-#{plugin_version}\.*")}$/)
+    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'), preserve: true)
+    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 #{plugin_version} 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
+    let(:env_var) { nil }
+    let(:which) { nil }
+    let(:nunit_version) { VersionInfo.new }
+
+    before {
+      described_class.setup('nunit-console.exe')
+    }
+
+    context 'TeamCity plugin path not in environment' do
+      let(:env_var) { nil }
+
+      it 'should skip reading the version' do
+        expect(BinaryVersionReader).to_not have_received(:read_from)
+      end
+    end
+
+    context 'NUnit executable not found' do
+      let(:env_var) { '/path/to/nunit plugins/nunit' }
+      let(:which) { nil }
+
+      it 'should skip reading the version' do
+        expect(BinaryVersionReader).to_not have_received(:read_from)
+      end
+    end
+
+    context 'NUnit executable without version' do
+      let(:env_var) { '/path/to/nunit plugins/nunit' }
+      let(:which) { 'path/to/nunit-console.exe' }
+
+      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_version) { VersionInfo.new({ file_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