rake-funnel 0.0.1.pre

data/spec/rake/funnel/tasks/environments_support/loader_spec.rb

@@ -0,0 +1,114 @@
+describe Rake::Funnel::Tasks::EnvironmentsSupport::Loader do
+  describe 'loading configuration' do
+    let(:config) {
+      {
+        name: 'environment name',
+        config_files: config_files.keys.map(&:to_s)
+      }
+    }
+
+    let(:config_files) {
+      {
+        one: 'one: 23',
+        two: 'two: 42'
+      }
+    }
+
+    let(:store) {
+      double(Configatron::Store).as_null_object
+    }
+
+    before {
+      config_files.each do |file, content|
+        allow(File).to receive(:read).with(file.to_s).and_return(content)
+      end
+
+      allow(Rake).to receive(:rake_output_message)
+    }
+
+    before {
+      described_class.load_configuration(config, store)
+    }
+
+    it 'should reinitialize the configatron store' do
+      expect(store).to have_received(:unlock!)
+      expect(store).to have_received(:reset!)
+    end
+
+    it 'should save the env to store' do
+      expect(store).to have_received(:env=).with(config[:name])
+    end
+
+    it 'should load all config files' do
+      config[:config_files].each do |file|
+        expect(File).to have_received(:read).with(file)
+      end
+    end
+
+    it "should add each config file's values to the store" do
+      expect(store).to have_received(:configure_from_hash).with({ 'one' => 23 })
+      expect(store).to have_received(:configure_from_hash).with({ 'two' => 42 })
+    end
+
+    it 'should lock the store' do
+      expect(store).to have_received(:lock!)
+    end
+
+    context 'config file with overriding values' do
+      let(:config_files) {
+        {
+          one: 'foo: bar',
+          two: 'foo: baz'
+        }
+      }
+
+      let(:store) {
+        Configatron::RootStore.new
+      }
+
+      it 'should merge config values' do
+        expect(store.foo).to eq('baz')
+      end
+    end
+
+    context 'env also defined in config file' do
+      let(:config_files) {
+        {
+          with_env: 'env: foo'
+        }
+      }
+
+      let(:store) {
+        Configatron::RootStore.new
+      }
+
+      it 'should override env from config' do
+        expect(store.env).to eq('foo')
+      end
+    end
+
+    context 'empty config file' do
+      let(:config_files) {
+        {
+          empty: ''
+        }
+      }
+
+      it 'should configure with empty hash' do
+        expect(store).to have_received(:configure_from_hash).with({})
+      end
+    end
+
+    context 'config file with ERb' do
+      let(:config_files) {
+        {
+          with_erb: 'foo: <%= 40 + 2 %>'
+        }
+      }
+
+      it 'should evaluate ERb' do
+        expect(store).to have_received(:configure_from_hash).with({ 'foo' => 42 })
+      end
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+include Rake
+include Rake::Funnel
+include Rake::Funnel::Support
+include Rake::Funnel::Tasks::MSBuildSupport
+
+describe Rake::Funnel::Tasks::MSBuild do
+  before {
+    Task.clear
+  }
+
+  describe 'defaults' do
+    its(:name) { should == :compile }
+    its(:project_or_solution) { should be_instance_of(Finder) }
+    its(:args) { should == {} }
+    its(:search_pattern) { should == %w(**/*.sln) }
+
+    describe 'build tool' do
+      before {
+        allow(BuildTool).to receive(:find).and_return('build tool')
+      }
+
+      it 'should use build tool finder' do
+        expect(subject.msbuild).to eq('build tool')
+      end
+    end
+  end
+
+  describe 'overriding defaults' do
+    context 'when msbuild executable is specified' do
+      subject {
+        described_class.new do |t|
+          t.msbuild = 'custom build tool.exe'
+        end
+      }
+
+      its(:msbuild) { should == 'custom build tool.exe' }
+    end
+
+    context 'when project or solution is specified' do
+      before {
+        allow(Finder).to receive(:new).and_call_original
+      }
+
+      subject {
+        described_class.new do |t|
+          t.project_or_solution = 'project.sln'
+        end
+      }
+
+      its(:project_or_solution) { should be_instance_of(Finder) }
+
+      it 'should set project or solution' do
+        expect(Finder).to have_received(:new).with('project.sln', subject, 'No projects or more than one project found.')
+      end
+    end
+  end
+
+  describe 'execution' do
+    let(:args) { {} }
+
+    let(:mapper) { double(Mapper).as_null_object }
+    let(:finder) { double(Finder).as_null_object }
+
+    before {
+      allow(subject).to receive(:sh)
+
+      allow(Mapper).to receive(:new).and_return(mapper)
+      allow(Finder).to receive(:new).and_return(finder)
+    }
+
+    before {
+      Task[subject.name].invoke
+    }
+
+    it 'should use solution finder' do
+      expect(finder).to have_received(:single)
+    end
+
+    it 'should use MSBuild mapper' do
+      expect(Mapper).to have_received(:new).with(:MSBuild)
+    end
+
+    it 'should map arguments' do
+      expect(mapper).to have_received(:map).with(args)
+    end
+
+    it 'should run with sh' do
+      expect(subject).to have_received(:sh)
+    end
+  end
+end

data/spec/rake/funnel/tasks/msbuild_support/build_tool_spec.rb

@@ -0,0 +1,21 @@
+describe Rake::Funnel::Tasks::MSBuildSupport::BuildTool do
+  before {
+    allow(Rake::Win32).to receive(:windows?).and_return(windows?)
+  }
+
+  context 'on Windows', platform: :win32 do
+    let(:windows?) { true }
+
+    it 'should find msbuild.exe' do
+      expect(described_class.find).to match(/msbuild\.exe$/)
+    end
+  end
+
+  context 'not on Windows' do
+    let(:windows?) { false }
+
+    it 'should find xbuild' do
+      expect(described_class.find).to eq('xbuild')
+    end
+  end
+end

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

@@ -0,0 +1,243 @@
+include Rake
+include Rake::Funnel
+include Rake::Funnel::Support
+include Rake::Funnel::Tasks::MSDeploySupport
+
+describe Rake::Funnel::Tasks::MSDeploy do
+  before {
+    CLEAN.clear
+    Task.clear
+  }
+
+  describe 'defaults' do
+    its(:name) { should == :msdeploy }
+    its(:msdeploy) { should == 'msdeploy' }
+    its(:log_file) { should == 'msdeploy.log' }
+    its(:args) { should == {} }
+
+    it 'should add the log file to the files to be cleaned' do
+      expect(CLEAN).to include(subject.log_file)
+    end
+  end
+
+  describe 'overriding defaults' do
+    context 'when task name is specified' do
+      it 'should have a default log file equal to the task name' do
+        expect(described_class.new(:foo).log_file).to eq('foo.log')
+      end
+    end
+
+    context 'when task name and log file is specified' do
+      subject! {
+        described_class.new(:foo) do |t|
+          t.log_file = 'bar.log'
+        end
+      }
+
+      it 'should use custom log file' do
+        expect(subject.log_file).to eq('bar.log')
+      end
+
+      it 'should add the log file to the files to be cleaned' do
+        expect(CLEAN).to include(subject.log_file)
+      end
+    end
+  end
+
+  describe 'execution' do
+    let(:msdeploy) { 'msdeploy' }
+    let(:args) { {} }
+
+    subject {
+      described_class.new do |t|
+        t.msdeploy = msdeploy
+        t.args = args
+      end
+    }
+
+    before {
+      allow(subject).to receive(:shell)
+
+      allow(RegistryPatch).to receive(:new).and_yield
+    }
+
+    describe 'argument mapping and invocation' do
+      let(:mapper) { double(Mapper).as_null_object }
+
+      before {
+        allow(Mapper).to receive(:new).and_return(mapper)
+      }
+
+      before {
+        Task[subject.name].invoke
+      }
+
+      it 'should use MSDeploy mapper' do
+        expect(Mapper).to have_received(:new).with(:MSDeploy)
+      end
+
+      it 'should map arguments' do
+        expect(mapper).to have_received(:map).with(args)
+      end
+
+      it 'should run with shell' do
+        expect(subject).to have_received(:shell).with(/^msdeploy /,
+            {
+              log_file: 'msdeploy.log',
+              error_lines: /^(error|[\w\.]*exception)/i
+            })
+      end
+    end
+
+    describe 'arg examples' do
+      before {
+        Task[subject.name].invoke
+      }
+
+      context 'skip actions' do
+        let (:args) {
+          {
+            verb: :sync,
+            source: {
+              content_path: 'deploy'
+            },
+            dest: {
+              computer_name: 'remote.example.com',
+              username: 'bob',
+              password: 'secret',
+              auto: true
+            },
+            skip: [
+              { directory: 'logs' },
+              {
+                object_name: 'filePath',
+                skip_action: 'Delete',
+                absolute_path: 'App_Offline\.htm$'
+              }
+            ],
+            use_checksum: nil,
+            allow_untrusted: nil
+          }
+        }
+
+        it 'should succeed' do
+          args = %w(
+            msdeploy
+            -verb:sync
+            -source:contentPath=deploy
+            -dest:computerName=remote.example.com,username=bob,password=secret,auto=true
+            -skip:directory=logs
+            -skip:objectName=filePath,skipAction=Delete,absolutePath=App_Offline\.htm$
+            -useChecksum
+            -allowUntrusted
+            )
+
+          expect(subject).to have_received(:shell).with(args.join(' '), be_an_instance_of(Hash))
+        end
+      end
+
+      context 'runCommand' do
+        let(:args) {
+          {
+            verb: :sync,
+            source: {
+              run_command: 'cd "C:\Program Files"',
+              wait_interval: 1
+            },
+            dest: {
+              computer_name: 'remote.example.com',
+              username: 'bob',
+              password: 'secret',
+              auto: true
+            }
+          }
+        }
+
+        it 'should succeed' do
+          args = %w(
+            msdeploy
+            -verb:sync
+            -source:runCommand="cd ""C:\Program Files""",waitInterval=1
+            -dest:computerName=remote.example.com,username=bob,password=secret,auto=true
+            )
+
+          expect(subject).to have_received(:shell).with(args.join(' '), be_an_instance_of(Hash))
+        end
+      end
+
+      context 'preSync runCommand' do
+        let(:args) {
+          {
+            verb: :sync,
+            pre_sync: {
+              run_command: 'cd "C:\Program Files"',
+              dont_use_command_exe: :true
+            },
+            source: {
+              content_path: 'deploy'
+            },
+            dest: {
+              computer_name: 'remote.example.com',
+              username: 'bob',
+              password: 'secret'
+            }
+          }
+        }
+
+        it 'should succeed' do
+          args = %w(
+            msdeploy
+            -verb:sync
+            -preSync:runCommand="cd ""C:\Program Files""",dontUseCommandExe=true
+            -source:contentPath=deploy
+            -dest:computerName=remote.example.com,username=bob,password=secret
+            )
+
+          expect(subject).to have_received(:shell).with(args.join(' '), be_an_instance_of(Hash))
+        end
+      end
+    end
+
+    describe "MSDeploy's idiocy" do
+      before {
+        Task[subject.name].invoke
+      }
+
+      describe 'version registry value that is required to exist' do
+        it 'should patch the registry' do
+          expect(RegistryPatch).to have_received(:new)
+        end
+      end
+
+      describe 'command line parser that requires quotes inside but not outside parameters' do
+        let(:msdeploy) { 'path to/msdeploy' }
+
+        let(:args) {
+          {
+            'simple key' => 'simple value',
+            hash: {
+              'hash key 1' => 'hash value 1',
+              'hash key 2' => 'hash value 2'
+            },
+            array: ['array value 1', 'array value 2'],
+            'some flag' => nil
+          }
+        }
+
+        it 'should quote the string' do
+          args = '"path to/msdeploy" -"simple key":"simple value" -hash:"hash key 1"="hash value 1","hash key 2"="hash value 2" -array:"array value 1" -array:"array value 2" -"some flag"'
+          args = %w(
+            "path to/msdeploy"
+            -"simple key":"simple value"
+            -hash:"hash key 1"="hash value 1","hash key 2"="hash value 2"
+            -array:"array value 1"
+            -array:"array value 2"
+            -"some flag"
+            ).join(' ')
+
+          expect(subject).to have_received(:shell).with(args, be_an_instance_of(Hash))
+        end
+      end
+    end
+  end
+end

data/spec/rake/funnel/tasks/msdeploy_support/registry_patch_spec.rb

@@ -0,0 +1,139 @@
+describe Rake::Funnel::Tasks::MSDeploySupport::RegistryPatch do
+  describe 'execution' do
+    it 'should yield block' do
+      result = 0
+
+      described_class.new do
+        result = 42
+      end
+
+      expect(result).to eq(42)
+    end
+
+    it 'should work without block' do
+      expect(lambda { described_class.new }).not_to raise_error
+    end
+  end
+
+  describe 'patching' do
+    context 'not on Windows' do
+      before {
+        allow_any_instance_of(described_class).to receive(:require).with('win32/registry').and_raise(LoadError)
+      }
+
+      it 'should succeed' do
+        expect(lambda { described_class.new }).not_to raise_error
+      end
+    end
+
+    context 'on Windows', platform: :win32 do
+      let(:root) { Win32::Registry::HKEY_LOCAL_MACHINE }
+
+      let(:keys) {
+        described_class::KEYS.map do |key|
+          instance_double(Win32::Registry, keyname: key)
+        end
+      }
+
+      def allow_open_or_create(key)
+        allow(root).to receive(:create).with(key.keyname).and_yield(key)
+      end
+
+      def allow_open_for_deletion(key)
+        allow(root).to receive(:create).with(File.dirname(key.keyname)).and_yield(key)
+      end
+
+      context 'MSDeploy registry key and "Version" value does not exist' do
+        before {
+          keys.each do |key|
+            allow(key).to receive(:created?).and_return(true)
+            allow(key).to receive(:[]).and_raise(Win32::Registry::Error.new('value does not exist, so getting it raises'.length))
+            allow(key).to receive(:[]=)
+            allow(key).to receive(:delete_key)
+          end
+        }
+
+        before {
+          keys.each do |key|
+            allow_open_or_create(key)
+            allow_open_for_deletion(key)
+          end
+        }
+
+        before {
+          described_class.new
+        }
+
+        it 'should create the key' do
+          keys.each do |key|
+            expect(root).to have_received(:create).with(key.keyname)
+          end
+        end
+
+        it 'should create the version' do
+          keys.each do |key|
+            expect(key).to have_received(:[]=).with('Version', described_class::FAKE_VERSION)
+          end
+        end
+
+        it 'should delete the key' do
+          keys.each do |key|
+            expect(key).to have_received(:delete_key).with(File.basename(key.keyname), true)
+          end
+        end
+      end
+
+      context 'MSDeploy registry key does exist' do
+        before {
+          keys.each do |key|
+            allow_open_or_create(key)
+          end
+        }
+
+        context '"Version" value does not exist' do
+          before {
+            keys.each do |key|
+              allow(key).to receive(:created?).and_return(false)
+              allow(key).to receive(:[]).and_raise(Win32::Registry::Error.new('value does not exist, so getting it raises'.length))
+              allow(key).to receive(:[]=)
+              allow(key).to receive(:delete_value)
+            end
+          }
+
+          before {
+            described_class.new
+          }
+
+          it 'should create the version' do
+            keys.each do |key|
+              expect(key).to have_received(:[]=).with('Version', described_class::FAKE_VERSION)
+            end
+          end
+
+          it 'should delete the version' do
+            keys.each do |key|
+              expect(key).to have_received(:delete_value).with(described_class::VERSION_VALUE)
+            end
+          end
+        end
+
+        context '"Version" value does exist' do
+          before {
+            keys.each do |key|
+              allow(key).to receive(:created?).and_return(false)
+              allow(key).to receive(:[])
+            end
+          }
+
+          before {
+            described_class.new
+          }
+
+          it 'should do nothing' do
+            expect(true).to eq(true)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+include Rake
+include Rake::Funnel
+include Rake::Funnel::Integration::TeamCity
+include Rake::Funnel::Support
+
+describe Rake::Funnel::Tasks::NUnit do
+  before {
+    Task.clear
+  }
+
+  describe 'defaults' do
+    its(:name) { should == :test }
+    its(:args) { should == {} }
+    its(:nunit) { should == 'nunit-console.exe' }
+    its(:files) { should == %w(build/specs/**/*.dll build/specs/**/*.exe) }
+  end
+
+  describe 'overriding defaults' do
+    context 'when NUnit executable is specified' do
+      subject {
+        described_class.new do |t|
+          t.nunit = 'custom nunit.exe'
+        end
+      }
+
+      its(:nunit) { should == 'custom nunit.exe' }
+    end
+  end
+
+  describe 'execution' do
+    let(:args) { {} }
+
+    let(:mapper) { double(Mapper).as_null_object }
+    let(:finder) { double(Finder).as_null_object }
+
+    before {
+      allow(subject).to receive(:sh)
+
+      allow(Mapper).to receive(:new).and_return(mapper)
+      allow(Finder).to receive(:new).and_return(finder)
+      allow(NUnitPlugin).to receive(:setup)
+
+      allow(Mono).to receive(:invocation).and_wrap_original do |original_method, *args, &block|
+        args.compact
+      end
+    }
+
+    before {
+      Task[subject.name].invoke
+    }
+
+    it 'should use test assembly finder' do
+      expect(finder).to have_received(:all)
+    end
+
+    it 'should set up TeamCity plugin' do
+      expect(NUnitPlugin).to have_received(:setup).with(subject.nunit)
+    end
+
+    it 'should use NUnit mapper' do
+      expect(Mapper).to have_received(:new).with(:NUnit)
+    end
+
+    it 'should map arguments' do
+      expect(mapper).to have_received(:map).with(args)
+    end
+
+    it 'should use mono invocation' do
+      expect(Mono).to have_received(:invocation).with(subject.nunit)
+    end
+
+    it 'should run with sh' do
+      expect(subject).to have_received(:sh)
+    end
+  end
+end