jsierles-sprinkle 0.1.9

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/gem_spec.rb

@@ -0,0 +1,75 @@
+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' }
+  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
+
+  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
+    
+  end
+
+end

data/spec/sprinkle/installers/installer_spec.rb

@@ -0,0 +1,151 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Sprinkle::Installers::Installer do
+  include Sprinkle::Deployment
+
+  before do
+    @package = mock(Sprinkle::Package, :name => 'package')
+    @empty = Proc.new { }
+    @sequence = ['op1', 'op2']
+    @delivery = mock(Sprinkle::Deployment, :process => true)
+    @installer = create_installer
+    @installer.delivery = @delivery
+    @roles = []
+    @deployment = deployment do
+      delivery :capistrano
+      installer do; prefix '/usr/bin'; end
+    end
+  end
+
+  def create_installer(&block)
+    installer = Sprinkle::Installers::Installer.new @package, &block
+    installer.stub!(:puts).and_return
+
+    # this is actually an abstract class so we'll insert a few fake install sequences
+    class << installer
+      def install_sequence
+        ['op1', 'op2']
+      end
+    end
+
+    installer
+  end
+
+  describe 'when created' do
+
+    it 'should belong to a package' do
+      @installer.package.should == @package
+    end
+
+    describe 'with a block to customize installer defaults' do
+
+      it 'should accept an optional block to customize installers defaults' do
+        @installer = create_installer do; prefix '/usr/local'; end
+        @installer.prefix.should == '/usr/local'
+      end
+
+      it 'should override any deployment level defaults' do
+        @installer = create_installer do; prefix '/usr/local'; end
+        @installer.defaults(@deployment)
+        @installer.prefix.should == '/usr/local'
+      end
+    end
+  end
+
+  describe 'during configuration' do
+    # We just check to make sure it has the Sprinkle::Configurable method
+    it 'should be configurable' do
+      @installer.should respond_to(:defaults)
+    end
+  end
+
+  describe 'during installation' do
+
+    it 'should request the install sequence from the concrete class' do
+      @installer.should_receive(:install_sequence).and_return(@sequence)
+    end
+
+    describe 'when testing' do
+
+      before do
+        Sprinkle::OPTIONS[:testing] = true
+        @logger = mock(ActiveSupport::BufferedLogger, :debug => true, :debug? => true)
+      end
+
+      it 'should not invoke the delivery mechanism with the install sequence' do
+        @delivery.should_not_receive(:process)
+      end
+
+      it 'should print the install sequence to the console' do
+        @installer.should_receive(:logger).twice.and_return(@logger)
+      end
+
+    end
+
+    describe 'when in production' do
+      it 'should invoke the delivery mechanism to process the install sequence' do
+        @delivery.should_receive(:process).with(@package.name, @sequence, @roles)
+      end
+    end
+    
+    describe "with a pre command" do
+      
+      def create_installer_with_pre_command(cmd="")
+        installer = Sprinkle::Installers::Installer.new @package do
+          pre :install, cmd
+          
+          def install_commands
+            ["installer"]
+          end          
+        end
+        
+        installer.stub!(:puts).and_return
+        installer.delivery = @delivery
+        installer
+      end
+      before do
+        @installer = create_installer_with_pre_command('run')
+      end
+      describe "string commands" do
+        it "should insert the pre command for the specific package in the installation process" do
+          @installer.send(:install_sequence).should == [ 'run', 'installer' ]
+        end
+      end      
+      describe "blocks as commands" do
+        before(:each) do          
+          @installer = Sprinkle::Installers::Installer.new @package do
+            pre :install do
+              %w(a b c)
+            end
+
+            def install_commands
+              ["installer"]
+            end          
+          end
+
+          @installer.stub!(:puts).and_return
+          @installer.delivery = @delivery
+        end
+        it "should be able to store a block if it's the pre command" do
+          @installer.send(:install_sequence).should == [ "a", "b", "c", 'installer' ]
+        end
+      end
+      describe "blocks as commands" do
+        before(:each) do
+          @array = ["a", "b"]
+          @installer = create_installer_with_pre_command(@array)
+        end
+        it "should be able to store a block if it's the pre command" do
+          @installer.send(:install_sequence).should == [ @array, 'installer' ].flatten
+        end
+      end
+    end
+
+    after do
+      @installer.process(@roles)
+      Sprinkle::OPTIONS[:testing] = false
+    end
+
+  end
+
+end