lachlan-sprinkle 0.0.1

data/spec/sprinkle/actors/capistrano_spec.rb

@@ -0,0 +1,170 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Sprinkle::Actors::Capistrano do
+
+  before do
+    @recipes = 'deploy'
+    @cap = ::Capistrano::Configuration.new
+    ::Capistrano::Configuration.stub!(:new).and_return(@cap)
+    @cap.stub!(:load).and_return
+  end
+
+  def create_cap(&block)
+    Sprinkle::Actors::Capistrano.new &block
+  end
+
+  describe 'when created' do
+
+    it 'should create a new capistrano object' do
+      ::Capistrano::Configuration.should_receive(:new).and_return(@cap)
+      create_cap
+    end
+
+    describe 'when verbose' do
+
+      before do
+        Sprinkle::OPTIONS[:verbose] = true
+      end
+
+      it 'should set verbose logging on the capistrano object' do
+        @cap = create_cap
+        @cap.config.logger.level.should == ::Capistrano::Logger::INFO
+      end
+
+    end
+
+    describe 'when not verbose' do
+
+      before do
+        Sprinkle::OPTIONS[:verbose] = false
+      end
+
+      it 'should set quiet logging on the capistrano object' do
+        @cap = create_cap
+        @cap.config.logger.level.should == ::Capistrano::Logger::IMPORTANT
+      end
+
+    end
+
+    describe 'with a block' do
+
+      before do
+        @actor = create_cap do
+          recipes 'cool gear' # default is deploy
+        end
+      end
+
+      it 'should evaluate the block against the actor instance' do
+        @actor.loaded_recipes.should include('cool gear')
+      end
+
+    end
+
+    describe 'without a block' do
+
+      it 'should automatically load the default capistrano configuration' do
+        @cap.should_receive(:load).with('deploy').and_return
+      end
+
+      after do
+        @actor = create_cap
+      end
+
+    end
+
+  end
+
+  describe 'recipes' do
+
+    it 'should add the recipe location to an internal store' do
+      @cap = create_cap do
+        recipes 'deploy'
+      end
+      @cap.loaded_recipes.should == [ @recipes ]
+    end
+
+    it 'should load the given recipe' do
+      @cap.should_receive(:load).with(@recipes).and_return
+      create_cap
+    end
+
+  end
+
+  describe 'processing commands' do
+
+    before do
+      @commands = %w( op1 op2 )
+      @roles    = %w( app )
+      @name     = 'name'
+
+      @cap = create_cap do; recipes 'deploy'; end
+      @cap.stub!(:run).and_return
+      
+      @testing_errors = false
+    end
+
+    it 'should dynamically create a capistrano task containing the commands' do
+      @cap.config.should_receive(:task).and_return
+    end
+
+    it 'should invoke capistrano task after creation' do
+      @cap.should_receive(:run).with(@name).and_return
+    end
+    
+    it 'should raise capistrano errors when suppressing parameter is not set' do
+      @testing_errors = true
+      
+      @cap.should_receive(:run).and_raise(::Capistrano::CommandError)
+      lambda { @cap.process @name, @commands, @roles }.should raise_error(::Capistrano::CommandError)
+    end
+    
+    it 'should not raise errors and instead return false when suppressing parameter is set' do
+      @testing_errors = true
+      
+      @cap.should_receive(:run).and_raise(::Capistrano::CommandError)
+      
+      value = nil
+      lambda { value = @cap.process(@name, @commands, @roles, true) }.should_not raise_error(::Capistrano::CommandError)
+      
+      value.should_not be
+    end
+
+    after do
+      @cap.process @name, @commands, @roles unless @testing_errors
+    end
+
+  end
+
+  describe 'generated task' do
+
+    before do
+      @commands = %w( op1 op2 )
+      @roles    = %w( app )
+      @name     = 'name'
+
+      @cap = create_cap do; recipes 'deploy'; end
+      @cap.config.stub!(:fetch).and_return(:sudo)
+      @cap.config.stub!(:invoke_command).and_return
+    end
+
+    it 'should use sudo to invoke commands when so configured' do
+      @cap.config.should_receive(:fetch).with(:run_method, :sudo).and_return(:sudo)
+    end
+
+    it 'should run the supplied commands' do
+      @cap.config.should_receive(:invoke_command).with('op1', :via => :sudo).ordered.and_return
+      @cap.config.should_receive(:invoke_command).with('op2', :via => :sudo).ordered.and_return
+    end
+
+    it 'should be applicable for the supplied roles' do
+      @cap.stub!(:run).and_return
+      @cap.config.should_receive(:task).with(:install_name, :roles => @roles).and_return
+    end
+
+    after do
+      @cap.process @name, @commands, @roles
+    end
+
+  end
+
+end

data/spec/sprinkle/actors/local_spec.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Sprinkle::Actors::Local do
+
+  before do
+    @local = Sprinkle::Actors::Local.new
+  end
+
+  describe 'when processing commands' do
+
+    before do
+      @commands = %w( op1 op2 )
+      @roles    = %w( app )
+      @name     = 'name'
+    
+      @local.stub!(:system).and_return
+    end
+
+    it 'should run the commands on the local system' do
+      @local.should_receive(:system).twice.and_return
+    end
+    
+    after do
+      @local.process @name, @commands, @roles
+    end
+
+  end
+
+end

data/spec/sprinkle/configurable_spec.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Sprinkle::Configurable do
+  module MyPrefix
+    class Configurable
+      include Sprinkle::Configurable
+    end
+  end
+  
+  before do
+    @configurable = MyPrefix::Configurable.new
+    @default = Proc.new { }
+    @defaults = { :configurable => @default }
+    @deployment.stub!(:defaults).and_return(@defaults)
+    @deployment.stub!(:style)
+  end
+
+  it 'should be configurable via external defaults' do
+    @configurable.should respond_to(:defaults)
+  end
+
+  it 'should select the defaults for the particular concrete installer class' do
+    @deployment.should_receive(:defaults).and_return(@defaults)
+    @defaults.should_receive(:[]).with(:configurable).and_return(@default)
+  end
+
+  it 'should configure the installer delivery mechansim' do
+    @configurable.should_receive(:instance_eval)
+  end
+
+  it 'should maintain an options hash set arbitrarily via method missing' do
+    @configurable.instance_eval do
+      hsv 'gts'
+    end
+    @configurable.hsv.should == 'gts'
+  end
+  
+  it 'should allow the delivery instance variable to be accessed' do
+    @configurable.delivery = "string"
+    @configurable.instance_variable_get(:@delivery).should eql("string")
+  end
+
+  after do
+    @configurable.defaults(@deployment)
+  end
+end

data/spec/sprinkle/deployment_spec.rb

@@ -0,0 +1,80 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Sprinkle::Deployment do
+  include Sprinkle::Deployment
+  
+  def create_deployment(&block)
+    deployment do
+      delivery :capistrano, &block
+      
+      source do
+        prefix '/usr/local'
+      end
+    end
+  end
+
+  describe 'when created' do
+
+    it 'should be invalid without a block descriptor' do
+      lambda { deployment }.should raise_error
+    end
+
+    it 'should be invalid without a delivery method' do
+      lambda { @deployment = deployment do; end }.should raise_error
+    end
+
+    it 'should optionally accept installer defaults' do 
+      @deployment = create_deployment
+      @deployment.should respond_to(:source)
+    end
+    
+    it 'should provide installer defaults as a proc when requested' do 
+      @deployment = create_deployment
+      @deployment.defaults[:source].class.should == Proc
+    end
+    
+  end 
+  
+  describe 'delivery specification' do
+    
+    before do
+      @actor = mock(Sprinkle::Actors::Capistrano)
+      Sprinkle::Actors::Capistrano.stub!(:new).and_return(@actor)
+    end
+
+    it 'should automatically instantiate the delivery type' do 
+      @deployment = create_deployment
+      @deployment.style.should == @actor
+    end
+
+    it 'should optionally accept a block to pass to the actor' do
+      lambda { @deployment = create_deployment }.should_not raise_error
+    end
+
+    describe 'with a block' do
+
+      it 'should pass the block to the actor for configuration' do
+        @deployment = create_deployment do; recipes 'deploy'; end
+      end
+
+    end
+  end
+  
+  describe 'when processing policies' do 
+    
+    before do 
+      @policy = mock(Policy, :process => true)
+      POLICIES = [ @policy ]
+      @deployment = create_deployment
+    end
+    
+    it 'should apply all policies, passing itself as the deployment context' do
+      @policy.should_receive(:process).with(@deployment).and_return
+    end
+    
+    after do
+      @deployment.process
+    end
+  end
+
+end

data/spec/sprinkle/extensions/array_spec.rb

@@ -0,0 +1,19 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Array, 'task name conversions' do
+  
+  it 'should be able to deliver a task name' do
+    ['build_essential'].to_task_name.should == 'build_essential'
+  end
+  
+  it 'should join multiple elements together with a _ char' do
+    ['gdb', 'gcc', 'g++'].to_task_name.should == 'gdb_gcc_g++'
+  end
+  
+  it 'should use the task name of the underlying array element' do
+    string = 'build-essential'
+    string.should_receive(:to_task_name).and_return('build_essential')
+    [string].to_task_name.should == 'build_essential'
+  end
+    
+end

data/spec/sprinkle/extensions/string_spec.rb

@@ -0,0 +1,21 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe String, 'task name conversions' do
+  
+  it 'should be able to deliver a task name' do
+    'build_essential'.to_task_name.should == 'build_essential'
+  end
+  
+  it 'should convert all - chars to _ in the task name' do
+    'build-essential'.to_task_name.should == 'build_essential'
+  end
+  
+  it 'should convert multiple - chars to _ chars in the task name' do
+    'build--essential'.to_task_name.should == 'build__essential'
+  end
+  
+  it 'should lowercase the task name' do
+    'BUILD-ESSENTIAL'.to_task_name.should == 'build_essential'
+  end
+  
+end

data/spec/sprinkle/installers/apt_spec.rb

@@ -0,0 +1,70 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Sprinkle::Installers::Apt do
+
+  before do
+    @package = mock(Sprinkle::Package, :name => 'package')
+  end
+
+  def create_apt(*debs, &block)
+    Sprinkle::Installers::Apt.new(@package, *debs, &block)
+  end
+
+  describe 'when created' do
+
+    it 'should accept a single package to install' do
+      @installer = create_apt 'ruby'
+      @installer.packages.should == [ 'ruby' ]
+    end
+
+    it 'should accept an array of packages to install' do
+      @installer = create_apt %w( gcc gdb g++ )
+      @installer.packages.should == ['gcc', 'gdb', 'g++']
+    end
+
+    it 'should remove options from packages list' do
+      @installer = create_apt 'ruby', :dependencies_only => true
+      @installer.packages.should == [ 'ruby' ]
+    end
+
+  end
+
+  describe 'during installation' do
+
+    before do
+      @installer = create_apt 'ruby' do
+        pre :install, 'op1'
+        post :install, 'op2'
+      end
+      @install_commands = @installer.send :install_commands
+    end
+
+    it 'should invoke the apt installer for all specified packages' do
+      @install_commands.should =~ /apt-get -qyu install ruby/
+    end
+
+    it 'should specify a non interactive mode to the apt installer' do
+      @install_commands.should =~ /DEBIAN_FRONTEND=noninteractive/
+    end
+
+    it 'should automatically insert pre/post commands for the specified package' do
+      @installer.send(:install_sequence).should == [ 'op1', %(DEBCONF_TERSE='yes' DEBIAN_PRIORITY='critical' DEBIAN_FRONTEND=noninteractive apt-get -qyu install ruby), 'op2' ]
+    end
+
+    it 'should install a specific version if defined'
+
+  end
+  
+  describe 'during dependencies only installation' do
+
+    before do
+      @installer = create_apt('ruby') { dependencies_only true }
+      @install_commands = @installer.send :install_commands
+    end
+
+    it 'should invoke the apt installer with build-dep command for all specified packages' do
+      @install_commands.should =~ /apt-get -qyu build-dep ruby/
+    end
+    
+  end
+end

data/spec/sprinkle/installers/bsd_port_spec.rb

@@ -0,0 +1,42 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Sprinkle::Installers::BsdPort do
+
+  before do
+    @package = mock(Sprinkle::Package, :name => 'package')
+  end
+
+  def create_port(ports, &block)
+    Sprinkle::Installers::BsdPort.new(@package, ports, &block)
+  end
+
+  describe 'when created' do
+
+    it 'should accept a single package to install' do
+      @installer = create_port 'lang/ruby'
+      @installer.port.should == 'lang/ruby'
+    end
+
+  end
+
+  describe 'during installation' do
+
+    before do
+      @installer = create_port 'lang/ruby' do
+        pre :install, 'op1'
+        post :install, 'op2'
+      end
+      @install_commands = @installer.send :install_commands
+    end
+
+    it 'should invoke the port installer for all specified packages' do
+      @install_commands.should =~ /cd \/usr\/ports\/lang\/ruby && make BATCH=yes install clean/
+    end
+
+    it 'should automatically insert pre/post commands for the specified package' do
+      @installer.send(:install_sequence).should == [ 'op1', 'sh -c \'cd /usr/ports/lang/ruby && make BATCH=yes install clean\'', 'op2' ]
+    end
+
+  end
+
+end

data/spec/sprinkle/installers/freebsd_pkg_spec.rb

@@ -0,0 +1,49 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Sprinkle::Installers::FreebsdPkg do
+
+  before do
+    @package = mock(Sprinkle::Package, :name => 'package')
+  end
+
+  def create_pkg(pkgs, &block)
+    Sprinkle::Installers::FreebsdPkg.new(@package, pkgs, &block)
+  end
+
+  describe 'when created' do
+
+    it 'should accept a single package to install' do
+      @installer = create_pkg 'ruby'
+      @installer.packages.should == [ 'ruby' ]
+    end
+
+    it 'should accept an array of packages to install' do
+      @installer = create_pkg %w( gcc gdb g++ )
+      @installer.packages.should == ['gcc', 'gdb', 'g++']
+    end
+
+  end
+
+  describe 'during installation' do
+
+    before do
+      @installer = create_pkg 'ruby' do
+        pre :install, 'op1'
+        post :install, 'op2'
+      end
+      @install_commands = @installer.send :install_commands
+    end
+
+    it 'should invoke the freebsd_pkg installer for all specified packages' do
+      @install_commands.should =~ /pkg_add -r ruby/
+    end
+
+    it 'should automatically insert pre/post commands for the specified package' do
+      @installer.send(:install_sequence).should == [ 'op1', 'pkg_add -r ruby', 'op2' ]
+    end
+
+    it 'should install a specific version if defined'
+
+  end
+
+end

data/spec/sprinkle/installers/gem_spec.rb

@@ -0,0 +1,91 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Sprinkle::Installers::Gem do
+
+  before do
+    @gem = 'rails'
+    @version = '2.0.2'
+    @options = { :source => 'http://gems.github.com/', :repository => '/tmp/gems', :build_flags => '--build_flag=foo' }
+  end
+
+  def create_gem(gem, version = nil, options = {}, &block)
+    @package = mock(Sprinkle::Package, :name => gem, :version => version, :source => nil, :repository => nil)
+    Sprinkle::Installers::Gem.new(@package, gem, options, &block)
+  end
+
+  describe 'when created' do
+
+    before do
+      @installer = create_gem @gem, @version, @options
+    end
+
+    it 'should accept a single package to install' do
+      @installer.gem.should == @gem
+    end
+
+    it 'should optionally store a version of the gem to install' do
+      @installer.version.should == '2.0.2'
+    end
+
+    it 'should optionally store a source location of the gem to install' do
+      @installer.source.should == 'http://gems.github.com/'
+    end
+
+    it 'should optionally store the repository location where gems are to be installed' do
+      @installer.repository.should == @options[:repository]
+    end
+    
+    it 'should optionally store the build flags' do
+      @installer.build_flags.should == @options[:build_flags]
+    end
+
+  end
+
+  describe 'during installation' do
+
+    describe 'without a version' do
+
+      before do
+        @installer = create_gem @gem do
+          pre :install, 'op1'
+          post :install, 'op2'
+        end
+      end
+
+      it 'should invoke the gem installer for the specified package' do
+        @installer.send(:install_commands).should == "gem install #{@gem} --no-rdoc --no-ri"
+      end
+
+      it 'should automatically insert pre/post commands for the specified package' do
+        @installer.send(:install_sequence).should == [ 'op1', "gem install #{@gem} --no-rdoc --no-ri", 'op2']
+      end
+
+    end
+
+    describe 'with a specific version' do
+
+      before do
+        @installer = create_gem @gem, @version, :build_docs => true
+      end
+
+      it 'should install a specific version if defined, and with docs' do
+        @installer.send(:install_commands).should == "gem install #{@gem} --version '#{@version}'"
+      end
+
+    end
+    
+    describe 'with build flags' do
+      
+      before do
+        @installer = create_gem @gem, nil, :build_flags => '--option=foo'
+      end
+      
+      it 'should install with defined build flags' do
+        @installer.send(:install_commands).should == "gem install #{@gem} --no-rdoc --no-ri -- --option=foo"
+      end
+      
+    end
+    
+  end
+
+end