rake-funnel 0.0.1.pre

data/spec/rake/funnel/tasks/paket_spec.rb

@@ -0,0 +1,184 @@
+include Rake
+include Rake::Funnel::Support
+
+describe Rake::Funnel::Tasks::Paket do
+  before {
+    Task.clear
+  }
+
+  describe 'defaults' do
+    its(:name) { should == :paket }
+    its(:paket) { should == '.paket/paket.exe' }
+    its(:paket_args) { should == 'restore' }
+    its(:bootstrapper) { should == '.paket/paket.bootstrapper.exe' }
+    its(:bootstrapper_args) { should == nil }
+  end
+
+  describe 'overriding defaults' do
+    context 'when bootstrapper executable is specified' do
+      subject {
+        described_class.new do |t|
+          t.bootstrapper = 'custom bootstrapper.exe'
+        end
+      }
+
+      its(:bootstrapper) { should == 'custom bootstrapper.exe' }
+    end
+
+    context 'when bootstrapper args are specified' do
+      subject {
+        described_class.new do |t|
+          t.bootstrapper_args = %w(arg1 arg2)
+        end
+      }
+
+      its(:bootstrapper_args) { should == %w(arg1 arg2) }
+    end
+
+    context 'when paket executable is specified' do
+      subject {
+        described_class.new do |t|
+          t.paket = 'custom paket.exe'
+        end
+      }
+
+      its(:paket) { should == 'custom paket.exe' }
+    end
+
+    context 'when paket args are specified' do
+      subject {
+        described_class.new do |t|
+          t.paket_args = %w(arg1 arg2)
+        end
+      }
+
+      its(:paket_args) { should == %w(arg1 arg2) }
+    end
+  end
+
+  describe 'execution' do
+    before {
+      allow(subject).to receive(:sh)
+      allow(Mono).to receive(:invocation).and_wrap_original do |original_method, *args, &block|
+        args.compact
+      end
+    }
+
+    context 'with overridden defaults' do
+      subject {
+        described_class.new do |t|
+          t.bootstrapper = 'custom bootstrapper.exe'
+          t.bootstrapper_args = %w(arg1 arg2)
+          t.paket = 'custom paket.exe'
+          t.paket_args = %w(arg1 arg2)
+        end
+      }
+
+      before {
+        allow(File).to receive(:exist?).with(subject.paket).and_return(false)
+        allow(subject).to receive(:sh)
+      }
+
+      before {
+        Task[subject.name].invoke
+      }
+
+      it 'should use custom bootstrapper' do
+        expect(subject).to have_received(:sh).with(subject.bootstrapper, subject.bootstrapper_args)
+      end
+
+      it 'should use custom paket' do
+        expect(subject).to have_received(:sh).with(subject.paket, subject.paket_args)
+      end
+    end
+
+    describe 'mono invocation' do
+      before {
+        Task[subject.name].invoke
+      }
+
+      it 'should use mono invocation for bootstrapper' do
+        expect(Mono).to have_received(:invocation).with(subject.bootstrapper, subject.bootstrapper_args)
+      end
+
+      it 'should use mono invocation for paket' do
+        expect(Mono).to have_received(:invocation).with(subject.paket, subject.paket_args)
+      end
+    end
+
+    describe 'optional download' do
+      before {
+        allow(File).to receive(:exist?).with(subject.paket).and_return(paket_exists)
+        allow(subject).to receive(:sh).with(subject.bootstrapper)
+      }
+
+      context 'success' do
+        before {
+          Task[subject.name].invoke
+        }
+
+        context 'paket.exe exists' do
+          let(:paket_exists) { true }
+
+          it 'should not run bootstrapper' do
+            expect(subject).not_to have_received(:sh).with(subject.bootstrapper)
+          end
+
+          it 'should run paket' do
+            expect(subject).to have_received(:sh).with(subject.paket, subject.paket_args)
+          end
+        end
+
+        context 'paket.exe does not exist' do
+          let(:paket_exists) { false }
+
+          it 'should run bootstrapper' do
+            expect(subject).to have_received(:sh).with(subject.bootstrapper)
+          end
+
+          it 'should run paket' do
+            expect(subject).to have_received(:sh).with(subject.paket, subject.paket_args)
+          end
+        end
+      end
+
+      context 'failure' do
+
+
+        context 'paket.exe exists' do
+          let(:paket_exists) { true }
+
+          context 'paket failed' do
+            before {
+              allow(subject).to receive(:sh).with(subject.paket, anything).and_raise
+            }
+
+            it 'should fail' do
+              expect(lambda { Task[subject.name].invoke }).to raise_error
+            end
+          end
+        end
+
+        context 'paket.exe does not exist' do
+          let(:paket_exists) { false }
+
+          context 'bootstrapper failed' do
+            before {
+              allow(subject).to receive(:sh).with(subject.bootstrapper).and_raise
+            }
+
+            it 'should not run paket' do
+              Task[subject.name].invoke rescue nil
+
+              expect(subject).not_to have_received(:sh).with(subject.paket, subject.paket_args)
+            end
+
+            it 'should fail' do
+              expect(lambda { Task[subject.name].invoke }).to raise_error
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/rake/funnel/tasks/quick_template_spec.rb

@@ -0,0 +1,89 @@
+require 'tmpdir'
+
+include Rake
+include Rake::Funnel::Support
+
+describe Rake::Funnel::Tasks::QuickTemplate do
+  before {
+    CLEAN.clear
+    Task.clear
+  }
+
+  describe 'defaults' do
+    its(:name) { should == :template }
+    its(:search_pattern) { should eq(%w(**/*.template)) }
+    its(:context) { should kind_of?(Binding) }
+
+    describe 'target files are cleaned' do
+      let(:templates) { [] }
+      let(:finder) { double(Finder).as_null_object }
+
+      before {
+        allow(finder).to receive(:all_or_default).and_return(templates)
+        allow(Finder).to receive(:new).and_return(finder)
+      }
+
+      subject! { described_class.new }
+
+      context 'no templates found' do
+        it 'should not add the target files' do
+          expect(CLEAN).to be_empty
+        end
+      end
+
+      context 'templates found' do
+        let(:templates) { %w(1.template foo/2.template bar/3.some_other_extension) }
+
+        it 'should add the target files' do
+          expect(CLEAN).to match_array(%w(1 foo/2 bar/3))
+        end
+      end
+    end
+  end
+
+  describe 'execution' do
+    let(:templates) { %w(1.template two/2.template) }
+
+    let(:finder) { double(Finder).as_null_object }
+    let(:engine) { TemplateEngine }
+
+    before {
+      allow(finder).to receive(:all_or_default).and_return(templates)
+      allow(Finder).to receive(:new).and_return(finder)
+      allow(engine).to receive(:render).and_return('file content')
+      allow(Rake).to receive(:rake_output_message)
+      allow(File).to receive(:read).and_return('template content')
+      allow(File).to receive(:write)
+    }
+
+    subject! { described_class.new }
+
+    before {
+      Task[subject.name].invoke
+    }
+
+    it 'should report created files' do
+      templates.each do |template|
+        expect(Rake).to have_received(:rake_output_message).with("Creating file #{template.ext}")
+      end
+    end
+
+    it 'should read all templates' do
+      templates.each do |template|
+        expect(File).to have_received(:read).with(template)
+      end
+    end
+
+    it 'should render all templates' do
+      templates.each do |template|
+        expect(engine).to have_received(:render).with('template content', template, subject.context)
+      end
+    end
+
+    it 'should write all files' do
+      templates.each do |template|
+        expect(File).to have_received(:write).with(template.ext, 'file content')
+      end
+    end
+  end
+end

data/spec/rake/funnel/tasks/side_by_side_specs_spec.rb

@@ -0,0 +1,58 @@
+require 'tmpdir'
+
+include Rake
+include Rake::Funnel::Support
+
+describe Rake::Funnel::Tasks::SideBySideSpecs do
+  before {
+    Task.clear
+  }
+
+  describe 'defaults' do
+    its(:name) { should == :compile }
+    its(:projects) { should == %w(**/*.csproj **/*.vbproj **/*.fsproj) }
+    its(:references) { should == [] }
+    its(:specs) { should == %w(*Specs.cs **/*Specs.cs *Tests.cs **/*Tests.cs) }
+    its(:enabled) { should == false }
+  end
+
+  describe 'execution' do
+    subject {
+      described_class.new do |t|
+        t.projects = %w(**/*.??proj)
+        t.references = %w(Ref-1)
+        t.specs = %w(*Specs.cs **/*Specs.cs)
+        t.enabled = enabled
+      end
+    }
+
+    before {
+      allow(Rake::Funnel::Tasks::SideBySideSpecsSupport::Remover).to receive(:remove)
+    }
+
+    before {
+      Task[subject.name].invoke
+    }
+
+    context 'enabled' do
+      let(:enabled) { true }
+
+      it 'should use remover' do
+        expect(Rake::Funnel::Tasks::SideBySideSpecsSupport::Remover).to have_received(:remove)
+            .with({
+                projects: subject.projects,
+                references: subject.references,
+                specs: subject.specs
+              })
+      end
+    end
+
+    context 'disabled' do
+      let(:enabled) { false }
+
+      it 'should do nothing' do
+        expect(Rake::Funnel::Tasks::SideBySideSpecsSupport::Remover).not_to have_received(:remove)
+      end
+    end
+  end
+end

data/spec/rake/funnel/tasks/side_by_side_specs_support/example/Sample.csproj

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <ItemGroup>
+    <Reference Include="Sample-Ref-1">
+      <HintPath>somewhere\Sample-Ref-1.dll</HintPath>
+    </Reference>
+    <Reference Include="Sample-Ref-2" />
+    <Reference Include="System" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Specs.cs" />
+    <Compile Include="FooCode.cs" />
+    <Compile Include="FooSpecs.cs" />
+    <Compile Include="subdir\BarCode.cs" />
+    <Compile Include="subdir\BarSpecs.cs" />
+  </ItemGroup>
+  <Choose>
+    <When Condition="ignored">
+      <ItemGroup>
+        <Reference Include="Sample-Ref-3">
+          <HintPath>packages\sample\sample.dll</HintPath>
+          <Private>True</Private>
+          <Paket>True</Paket>
+        </Reference>
+      </ItemGroup>
+    </When>
+  </Choose>
+</Project>

data/spec/rake/funnel/tasks/side_by_side_specs_support/remover_spec.rb

@@ -0,0 +1,116 @@
+describe Rake::Funnel::Tasks::SideBySideSpecsSupport::Remover do
+  describe 'removal' do
+    let(:projects) { [] }
+    let(:references) { [] }
+    let(:specs) { [] }
+
+    before {
+      allow(Dir).to receive(:[]).and_return(%w(project.proj))
+      allow(File).to receive(:read).and_return('<root></root>')
+      allow(File).to receive(:open)
+      allow(RakeFileUtils).to receive(:rm)
+    }
+
+    before {
+      described_class.remove({
+          projects: projects,
+          references: references,
+          specs: specs
+        })
+    }
+
+    describe 'arguments' do
+      context 'string projects' do
+        let(:projects) { '**/*.??proj' }
+
+        it 'should succeed' do
+          expect(true).to be(true)
+        end
+      end
+
+      context 'string references' do
+        let(:projects) { '**/*.??proj' }
+        let(:references) { 'Reference' }
+
+        it 'should succeed' do
+          expect(true).to be(true)
+        end
+      end
+
+      context 'string specs' do
+        let(:projects) { '**/*.??proj' }
+        let(:specs) { '*Specs.cs' }
+
+        it 'should succeed' do
+          expect(true).to be(true)
+        end
+      end
+    end
+
+    context 'project unchanged' do
+      let(:projects) { '**/*.??proj' }
+      let(:references) { 'Reference' }
+      let(:specs) { '*Specs.cs' }
+
+      it 'should not write XML' do
+        expect(File).not_to have_received(:open)
+      end
+    end
+  end
+
+  describe 'example' do
+    let(:projects) { %w(**/*.??proj) }
+    let(:references) { %w(Sample-Ref-1 Sample-Ref-2 Sample-Ref-3) }
+    let(:specs) { %w(*Specs.cs **/*Specs.cs) }
+
+    let(:temp_dir) { Dir.mktmpdir }
+
+    before {
+      FileUtils.cp_r(File.join(File.dirname(__FILE__), 'example/.'), temp_dir)
+    }
+
+    before {
+      allow(RakeFileUtils).to receive(:rm)
+    }
+
+    before {
+      Dir.chdir(temp_dir) do
+        described_class.remove({
+            projects: projects,
+            references: references,
+            specs: specs
+          })
+      end
+    }
+
+    after {
+      FileUtils.rm_rf(temp_dir)
+    }
+
+    describe 'code files' do
+      it 'should keep production code' do
+        expect(RakeFileUtils).not_to have_received(:rm).with('Code.cs')
+      end
+
+      it 'should delete specs' do
+        expect(RakeFileUtils).to have_received(:rm).with('Specs.cs')
+        expect(RakeFileUtils).to have_received(:rm).with('FooSpecs.cs')
+        expect(RakeFileUtils).to have_received(:rm).with('subdir/BarSpecs.cs')
+      end
+    end
+
+    describe 'projects' do
+      def project_xml
+        File.read(File.join(temp_dir, 'Sample.csproj'))
+      end
+
+      it 'should remove references' do
+        expect(project_xml).not_to include('Sample-Ref-1', 'Sample-Ref-2', 'Sample-Ref-3')
+      end
+
+      it 'should remove spec files' do
+        expect(project_xml).not_to include('Specs.cs', 'SampleSpecs.cs')
+      end
+    end
+  end
+end

data/spec/rake/funnel/tasks/timing_spec.rb

@@ -0,0 +1,133 @@
+include Rake
+
+describe Rake::Funnel::Tasks::Timing do
+  include DSL
+
+  before {
+    Rake.application = nil
+    Task.clear
+
+    expect(define_tasks).to be
+    expect(subject).to be
+  }
+
+  let(:define_tasks) { task :task }
+
+  after {
+    subject.reset!
+  }
+
+  describe 'defaults' do
+    its(:name) { should == :timing }
+    its(:stats) { should have(0).items }
+  end
+
+  describe 'task is automatically executed' do
+    it 'should add itself to the top level tasks' do
+      expect(Rake.application.top_level_tasks).to include(:timing)
+    end
+
+    it 'should append itself to the top level tasks' do
+      allow(Rake.application).to receive(:handle_options).and_return([])
+      Rake.application.init
+
+      described_class.new
+
+      expect(Rake.application.top_level_tasks).to have_at_least(2).items
+      expect(Rake.application.top_level_tasks.last).to eq(:timing)
+    end
+
+    context 'task defined in namespace' do
+      it 'should add namespaced top level task' do
+        allow(Rake.application).to receive(:handle_options).and_return([])
+        Rake.application.init
+
+        namespace :namespace do
+          described_class.new
+        end
+
+        expect(Rake.application.top_level_tasks).to include('namespace:timing')
+      end
+    end
+  end
+
+  describe 'execution' do
+    before {
+      allow(Rake.application).to receive(:init)
+      allow(Rake.application).to receive(:load_rakefile)
+      Rake.application.top_level_tasks.unshift(:task)
+      allow(Rake.application).to receive(:exit_because_of_exception)
+
+      allow($stdout).to receive(:puts)
+      allow($stderr).to receive(:puts)
+      # The 'rake aborted!' message is #printed on $stderr.
+      allow($stderr).to receive(:print)
+
+      Rake.application.run
+    }
+
+    context 'with task defined' do
+      let(:define_tasks) {
+        task :task do
+          puts 'hello'
+        end
+      }
+
+      it 'should execute tasks' do
+        expect($stdout).to have_received(:puts).with('hello')
+      end
+
+      it 'should record timing information for executed tasks' do
+        expect(subject.stats).to have(2).items
+        expect(subject.stats.first[:task].name).to eq('task')
+        expect(subject.stats.first[:time]).to be_a(Float)
+      end
+
+      it 'should record timing information for itself' do
+        expect(subject.stats).to have(2).items
+
+        # Ruby has no #last on Enumerable, WTF.
+        expect(subject.stats.reverse_each.first[:task].name).to eq('timing')
+      end
+    end
+
+    context 'with unreachable task defined' do
+      let(:define_tasks) {
+        task :task
+        task :not_executed
+      }
+
+      it 'should not record timing information for unexecuted tasks' do
+        expect(subject.stats.map { |s| s[:task].name }).not_to include('not_executed')
+      end
+    end
+
+    describe 'build finished' do
+      context 'when rake succeeded' do
+        it 'should print the report' do
+          expect($stdout).to have_received(:puts).with(/Build time report/)
+        end
+
+        it 'should report success' do
+          expect($stdout).to have_received(:puts).with(/Status\s+OK/)
+        end
+      end
+
+      context 'when rake failed' do
+        let(:define_tasks) {
+          task :task do
+            raise
+          end
+        }
+
+        it 'should print the report' do
+          expect($stdout).to have_received(:puts).with(/Build time report/)
+        end
+
+        it 'should report failure' do
+          expect($stderr).to have_received(:puts).with(/Status\s+Failed/)
+        end
+      end
+    end
+  end
+end