blazing 0.4.2 → 0.5.0

data/spec/blazing/config_spec.rb

@@ -1,129 +1,49 @@
 require 'spec_helper'
-require 'blazing/config'
+require_relative '../../lib/blazing/config'
 
 describe Blazing::Config do
+  let(:config) { Blazing::Config.new }
 
   describe '#initialize' do
     it 'takes the path of the config file as an argument' do
       config = Blazing::Config.new('/some/where/config.rb')
-      config.file.should == '/some/where/config.rb'
+      expect(config.file).to eq '/some/where/config.rb'
     end
 
     it 'takes the default config path if no path is specified' do
       config = Blazing::Config.new
-      config.file.should == 'config/blazing.rb'
+      expect(config.file).to eq 'config/blazing.rb'
     end
   end
 
   describe '.parse' do
-
     it 'returns a config object' do
-      Blazing::Config.parse('spec/support/empty_config.rb').should be_a Blazing::Config
-    end
-
-  end
-
-  describe '#default_target' do
-
-    it 'returns a target object if only one is present' do
-      config = Blazing::Config.new
-      config.target :sometarget, 'somewhere'
-      config.default_target.name.should be :sometarget
-    end
-
-  end
-
-  describe 'DSL' do
-
-    before :each do
-      @config = Blazing::Config.new
-    end
-
-    describe 'target' do
-
-      it 'creates a target object for each target call' do
-        @config.target :somename, 'someuser@somehost:/path/to/deploy/to'
-        @config.target :someothername, 'someuser@somehost:/path/to/deploy/to'
-
-        @config.targets.each { |t| t.should be_a Blazing::Target }
-        @config.targets.size.should be 2
-      end
-
-      it 'does not allow the creation of two targets with the same name' do
-        @config.target :somename, 'someuser@somehost:/path/to/deploy/to'
-        lambda { @config.target :somename, 'someuser@somehost:/path/to/deploy/to' }.should raise_error
-      end
+      expect(Blazing::Config.parse('spec/support/empty_config.rb')).to be_a Blazing::Config
     end
 
-    describe 'recipe' do
-
-      before :each do
-        class Blazing::Recipe::Dummy < Blazing::Recipe
-        end
-      end
-
-      it 'is an empty array if nothing was set' do
-        @config.recipes.should be_a Array
-      end
-
-      it 'accepts a single recipe as argument' do
-        @config.recipe :dummy
-        @config.recipes.first.should be_a Blazing::Recipe::Dummy
-      end
-
-      it 'allows multiple recipes to be defined' do
-        @config.recipe :dummy
-        @config.recipe :dummy
-        @config.recipes.size.should be 2
-        @config.recipes.each { |r| r.should be_a Blazing::Recipe::Dummy }
-      end
-
-      it 'passes the options to the recipe initializer' do
-        @config.recipe :dummy, :something => 'blah'
-        @config.recipes.first.options[:something].should == 'blah'
-      end
+    it 'creates a new DSL object and instance_evals the config file' do
+      dsl_double = double('dsl double')
+      expect(Blazing::DSL).to receive(:new).and_return(dsl_double)
+      expect(dsl_double).to receive(:instance_eval)
+      Blazing::Config.parse('spec/support/empty_config.rb')
     end
 
-    describe 'rake' do
-
-      it 'takes the name of the rake task as argument' do
-        @config.rake :post_deploy
-        @config.instance_variable_get('@rake').should == { :task => :post_deploy }
-      end
-
-      it 'accepts environment variables to pass along to rake' do
-        @config.rake :post_deploy, 'RAILS_ENV=production'
-        @config.instance_variable_get('@rake').should == { :task => :post_deploy, :env => 'RAILS_ENV=production' }
-      end
-
+    it 'loads the actual data from the config file' do
+      config = Blazing::Config.parse('spec/support/dummy_config.rb')
+      expect(config.targets.size).to be 1
+      expect(config.target(:staging)).to be_a Blazing::Target
     end
+  end
 
-    describe 'rvm' do
-
-      it 'takes an rvm string as argument' do
-        @config.rvm 'ruby-1.9.2@rails31'
-        @config.instance_variable_get('@rvm').should == 'ruby-1.9.2@rails31'
-      end
-
-      it 'returns the rvm string if no argument given' do
-        @config.rvm 'ruby-1.9.2@rails31'
-        @config.rvm.should == 'ruby-1.9.2@rails31'
-      end
-
+  describe 'target' do
+    it 'returns a target object if the target exists in config' do
+      target = double('dummy_target', name: 'foo')
+      config.targets << target
+      expect(config.target('foo')).to be target
     end
 
-    describe 'rvm_scripts' do
-
-      it 'takes an string as argument' do
-        @config.rvm_scripts '/opt/rvm/scripts'
-        @config.instance_variable_get('@env_scripts').should == '/opt/rvm/scripts'
-      end
-
-      it 'returns the string if no argument given' do
-        @config.rvm_scripts '/opt/rvm/scripts'
-        @config.rvm_scripts.should == '/opt/rvm/scripts'
-      end
-
+    it 'returns nil if the target does not exist in config' do
+      expect(config.target('foo')).to be nil
     end
   end
 end

data/spec/blazing/dsl_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+require 'blazing/dsl'
+
+module Blazing
+  describe DSL do
+    let(:dsl) { Blazing::DSL.new(config) }
+    let(:config) { double('config') }
+
+    describe 'target' do
+      let(:config) { double('config', targets: []) }
+
+      it 'adds a target to the config object' do
+        dsl.target :somename, 'someuser@somehost:/path/to/deploy/to'
+        dsl.target :someothername, 'someuser@somehost:/path/to/deploy/to'
+        expect(config.targets.size).to be 2
+      end
+
+      it 'does not allow the creation of two targets with the same name' do
+        dsl.target :somename, 'someuser@somehost:/path/to/deploy/to'
+        expect { dsl.target :somename, 'someuser@somehost:/path/to/deploy/to' }.to raise_error(RuntimeError, 'Name already taken')
+        expect(config.targets.size).to be 1
+      end
+    end
+
+    describe 'rake' do
+      it 'sets the rake task to the given name' do
+        expect(config).to receive(:rake_task=).with('some_task')
+        dsl.rake 'some_task'
+      end
+    end
+
+    describe 'env_script' do
+      it 'sets the env script to the given path' do
+        expect(config).to receive(:env_script=).with('/path/to/script')
+        dsl.env_script '/path/to/script'
+      end
+    end
+
+    describe 'rvm_scripts' do
+      it 'is deprecated and outputs a warning' do
+        expect(dsl).to receive(:warn)
+        dsl.rvm_scripts '/path/to/script'
+      end
+    end
+
+    describe 'rvm' do
+      it 'is deprecated and outputs a warning' do
+        expect(dsl).to receive(:warn)
+        dsl.rvm '/path/to/script'
+      end
+    end
+
+    describe 'recipes' do
+      it 'is deprecated and outputs a warning' do
+        expect(dsl).to receive(:warn)
+        dsl.recipes '/path/to/script'
+      end
+    end
+  end
+end

data/spec/blazing/hook_spec.rb

@@ -1,148 +1,97 @@
 require 'spec_helper'
+require 'blazing/hook'
+require 'blazing/config'
 
 module Blazing
-
-  class Recipe::Dummy < Blazing::Recipe
-  end
-
   describe Hook do
-
-    let(:config) { Config.new }
+    let(:config) { Blazing::Config.new }
 
     describe '#rake_command' do
-      it 'prepends the environment variables specified in the rake call' do
-        config.rake :deploy, 'SOMEFUNKYVARIABLE=foobar'
-        target = Blazing::Target.new(:sometarget, '/path', config)
+      it 'prepends the RAILS_ENV specified as :rails_env option to the target call' do
+        config.rake_task = :deploy
+        target = Blazing::Target.new(:sometarget, '/path', config, rails_env: 'production')
         hook = Hook.new(target)
-        hook.rake_command.should == 'SOMEFUNKYVARIABLE=foobar  bundle exec rake deploy'
+        expect(hook.rake_command).to eq('RAILS_ENV=production bundle exec rake deploy')
       end
 
-      it 'appends the RAILS_ENV specified as :rails_env option to the target call' do
-        config.rake :deploy
-        target = Blazing::Target.new(:sometarget, '/path', config, :rails_env => 'production')
+      it 'prepends the any other option specified specified in the target call' do
+        config.rake_task = :deploy
+        target = Blazing::Target.new(:sometarget, '/path', config, rails_env: 'production', foo: 'bar')
         hook = Hook.new(target)
-        hook.rake_command.should == ' RAILS_ENV=production bundle exec rake deploy'
+        expect(hook.rake_command).to include('RAILS_ENV=production')
+        expect(hook.rake_command).to include('FOO=bar')
+        expect(hook.rake_command).to include('bundle exec rake deploy')
       end
 
       it 'returns nil when no rake task was specified in config' do
-        target = Blazing::Target.new(:sometarget, '/path', config, :rails_env => 'production')
+        target = Blazing::Target.new(:sometarget, '/path', config, rails_env: 'production')
         hook = Hook.new(target)
-        hook.rake_command.should be nil
+        expect(hook.rake_command).to be nil
       end
     end
 
     describe 'Generated Hook' do
-
-      let(:target) { Blazing::Target.new(:sometarget, '/path', config, :rails_env => 'production') }
+      let(:target) { Blazing::Target.new(:sometarget, '/path', config, rails_env: 'production') }
       let(:hook_file) { Hook.new(target).send(:generate_hook) }
 
       context 'Always' do
         it 'logs the header with the target name' do
-          hook_file.should  include("ENTERING POST RECEIVE HOOK FOR: sometarget")
+          expect(hook_file).to include('ENTERING POST RECEIVE HOOK FOR: sometarget')
         end
 
         it 'goes one directory up' do
-          hook_file.should include('cd ..')
+          expect(hook_file).to include('cd ..')
         end
 
         it 'sets the GIT_DIR variable to .git' do
-          hook_file.should include("GIT_DIR='.git'")
+          expect(hook_file).to include("GIT_DIR='.git'")
         end
 
         it 'does a hard reset' do
-          hook_file.should include("git reset --hard HEAD")
+          expect(hook_file).to include('git reset --hard HEAD')
         end
 
         it 'checks out the pushed branch' do
-          hook_file.should include("git checkout $refname")
+          expect(hook_file).to include('git checkout $refname')
         end
 
         it 'resets the GIT_DIR variable' do
-          hook_file.should include("unset GIT_DIR")
+          expect(hook_file).to include('unset GIT_DIR')
         end
 
         it 'resets the GIT_WORK_TREE variable' do
-          hook_file.should include("unset GIT_WORK_TREE")
+          expect(hook_file).to include('unset GIT_WORK_TREE')
         end
 
         it 'runs bundler with the correct options' do
-          hook_file.should include("bundle --deployment --quiet --without development test")
-        end
-      end
-
-      context 'RVM Setup' do
-        context 'when rvm is enabled' do
-          context 'loading rvm' do
-            it 'uses the load mechanism suggested by rvm' do
-              config.rvm 'someruby@somegemset'
-              hook_file.should include("source \"$HOME/.rvm/scripts/rvm\"")
-              hook_file.should include("source \"/usr/local/rvm/scripts/rvm\"")
-            end
-
-            it 'sources the rvm_scripts directory when rvm_scripts is specified' do
-              config.rvm 'someruby@somegemset'
-              config.rvm_scripts '/location/of/rvm/scripts'
-              hook_file.should include("source /location/of/rvm/scripts")
-            end
-          end
-
-          context 'loading the rvm ruby and gemset' do
-            it 'sources the rvmrc to load the env' do
-              config.rvm 'someruby@somegemset'
-              hook_file.should include("rvm use someruby@somegemset")
-            end
-
-            it 'uses rvm use to load the env when an rvm string was specified' do
-              config.rvm :rvmrc
-              hook_file.should include("source .rvmrc")
-            end
-          end
-        end
-
-        context 'when rvm is disabled' do
-          it 'does not include any rvm handling' do
-            hook_file.should_not include("Loading rvm")
-          end
+          expect(hook_file).to include('bundle --deployment --quiet --without development test')
         end
       end
 
-      context 'Recipes Handling' do
-
-        context 'when there are no recipes configured' do
-          it 'does not run blazing recipes' do
-            hook_file.should_not include("bundle exec blazing recipes")
-          end
-        end
-
-        context 'when there are recipes configured' do
-          before :each do
-            config.recipe :dummy
-          end
-
-          it 'runs the blazing recipes command with the correct target name' do
-            hook_file.should include("bundle exec blazing recipes sometarget")
-          end
+      context 'env script' do
+        it 'sources the specified directory when env_script is specified' do
+          config.env_script = '/location/of/script'
+          expect(hook_file).to include('source /location/of/script')
         end
       end
 
       context 'Rake Command Handling' do
         context 'when the rake_command is specified' do
           before :each do
-            config.rake :deploy
+            config.rake_task = :deploy
           end
 
           it 'runs the rake command' do
-            hook_file.should include(' RAILS_ENV=production bundle exec rake deploy')
+            expect(hook_file).to include(' RAILS_ENV=production bundle exec rake deploy')
           end
         end
 
         context 'when no rake_command is specified' do
           it 'does not run the rake_command' do
-            hook_file.should_not include(" RAILS_ENV=production bundle exec rake")
+            expect(hook_file).not_to include(' RAILS_ENV=production bundle exec rake')
           end
         end
       end
     end
   end
 end
-

data/spec/blazing/integration/deployment_spec.rb

@@ -1,32 +1,30 @@
 require 'spec_helper'
 
 describe 'deployment with git push' do
+  before :each do
+    setup_sandbox
+    # @config = Blazing::Config.new
+    # @config.target :production, "#{@sandbox_directory}/target"
+    # @config.target :staging, "#{@sandbox_directory}/staging"
+    # @cli = Blazing::CLI.new
+    # Blazing::Config.stub(:parse).and_return @config
+  end
 
-    before :each do
-      setup_sandbox
-      #@config = Blazing::Config.new
-      #@config.target :production, "#{@sandbox_directory}/target"
-      #@config.target :staging, "#{@sandbox_directory}/staging"
-      #@cli = Blazing::CLI.new
-      #Blazing::Config.stub(:parse).and_return @config
-    end
+  after :each do
+    teardown_sandbox
+  end
 
-    after :each do
-      teardown_sandbox
-    end
+  context 'git push <remote> <ref>' do
+    it 'deploys the pushed ref'
+  end
 
-    context 'git push <remote> <ref>' do
+  context 'git push <remote>' do
+    context 'when one ref is pushed' do
       it 'deploys the pushed ref'
     end
 
-    context 'git push <remote>' do
-      context 'when one ref is pushed' do
-        it 'deploys the pushed ref'
-      end
-
-      context 'when multiple refs are pushed' do
-        it 'deploys the currently checked out ref'
-      end
+    context 'when multiple refs are pushed' do
+      it 'deploys the currently checked out ref'
     end
- end
-
+  end
+end

data/spec/blazing/integration/init_spec.rb

@@ -3,7 +3,6 @@ require 'blazing/config'
 require 'blazing/commands'
 
 describe '$ blazing init' do
-
   before :each do
     setup_sandbox
     Blazing::Commands.new.init
@@ -14,11 +13,10 @@ describe '$ blazing init' do
   end
 
   it 'creates a config directory if none exists yet' do
-    File.exists?('config').should be true
+    expect(File.exist?('config')).to be true
   end
 
   it 'creates a config file in config/blazing.rb' do
-    File.exists?('config/blazing.rb').should be true
+    expect(File.exist?('config/blazing.rb')).to be true
   end
 end
-