auser-sprinkle 0.1.5

data/spec/sprinkle/installers/rpm_spec.rb

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

data/spec/sprinkle/installers/source_spec.rb

@@ -0,0 +1,331 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Sprinkle::Installers::Source do
+  include Sprinkle::Deployment
+
+  before do
+    @source = 'ftp://ftp.ruby-lang.org/pub/ruby/1.8/ruby-1.8.6-p111.tar.gz'
+
+    @deployment = deployment do
+      delivery :capistrano
+      source do
+        prefix   '/usr'
+        archives '/usr/archives'
+        builds   '/usr/builds'
+      end
+    end
+
+    @installer = create_source @source do
+      prefix   '/usr/local'
+      archives '/usr/local/archives'
+      builds   '/usr/local/builds'
+
+      enable %w( headers ssl deflate so )
+      disable %w( cache proxy rewrite )
+
+      with %w( debug extras )
+      without %w( fancyisms )
+    end
+
+    @installer.defaults(@deployment)
+  end
+
+  def create_source(source, version = nil, &block)
+    @package = mock(Sprinkle::Package, :name => 'package', :version => version)
+    Sprinkle::Installers::Source.new(@package, source, &block)
+  end
+
+  describe 'when created' do
+
+    it 'should accept a source archive name to install' do
+      @installer.source.should == @source
+    end
+
+  end
+
+  describe 'before installation' do
+
+    before do
+      @settings = { :prefix => '/usr/local', :archives => '/usr/local/tmp', :builds => '/usr/local/stage' }
+    end
+
+    it 'should fail if no installation area has been specified' do
+      @settings.delete(:prefix)
+    end
+
+    it 'should fail if no build area has been specified' do
+      @settings.delete(:builds)
+    end
+
+    it 'should fail if no source download area has been specified' do
+      @settings.delete(:archives)
+    end
+
+    after do
+      @settings.each { |k, v| @installer.send k, v }
+      lambda { @installer.install_sequence }.should raise_error
+    end
+
+  end
+
+  describe  'customized configuration' do
+
+    it 'should support specification of "enable" options' do
+      @installer.enable.should == %w( headers ssl deflate so )
+    end
+
+    it 'should support specification of "disable" options' do
+      @installer.disable.should == %w( cache proxy rewrite )
+    end
+
+    it 'should support specification of "with" options' do
+      @installer.with.should == %w( debug extras )
+    end
+
+    it 'should support specification of "without" options' do
+      @installer.without.should == %w( fancyisms )
+    end
+
+    it 'should support customized build area' do
+      @installer.prefix.should == '/usr/local'
+    end
+
+    it 'should support customized source area' do
+      @installer.archives.should == '/usr/local/archives'
+    end
+
+    it 'should support customized install area' do
+      @installer.builds.should == '/usr/local/builds'
+    end
+
+  end
+
+  describe 'during gnu source archive style installation' do
+
+    it 'should prepare the build, installation and source archives area' do
+      @installer.should_receive(:prepare).and_return(
+        [
+         'mkdir -p /usr/local',
+         'mkdir -p /usr/local/builds',
+         'mkdir -p /usr/local/archives'
+        ]
+      )
+
+    end
+
+    it 'should download the source archive' do
+      @installer.should_receive(:download).and_return(
+        [
+         "wget -cq --directory-prefix='/usr/local/archives' #{@source}"
+        ]
+      )
+    end
+
+    it 'should extract the source archive' do
+      @installer.should_receive(:extract).and_return(
+        [
+         "bash -c 'cd /usr/local/builds && tar xzf /usr/local/archives/ruby-1.8.6-p111.tar.gz"
+        ]
+      )
+    end
+
+    it 'should configure the source' do
+      enable  = %w( headers ssl deflate so ).inject([]) { |m, value| m << "--enable-#{value}"; m }
+      disable = %w( cache proxy rewrite ).inject([]) { |m, value| m << "--disable-#{value}"; m }
+
+      with    = %w( debug extras ).inject([]) { |m, value| m << "--with-#{value}"; m }
+      without = %w( fancyisms ).inject([]) { |m, value| m << "--without-#{value}"; m }
+
+      options = "#{enable.join(' ')} #{disable.join(' ')} #{with.join(' ')} #{without.join(' ')}"
+
+      @installer.should_receive(:build).and_return(
+        [
+         "bash -c 'cd /usr/local/builds && ./configure --prefix=/usr/local #{options} > #{@package.name}-configure.log 2>&1'"
+        ]
+      )
+    end
+
+    it 'should build the source' do
+      @installer.should_receive(:build).and_return(
+        [
+         "bash -c 'cd /usr/local/builds && make > #{@package.name}-build.log 2>&1'"
+        ]
+      )
+    end
+
+    it 'should install the source' do
+      @installer.should_receive(:install).and_return(
+        [
+         "bash -c 'cd /usr/local/builds && make install > #{@package.name}-install.log 2>&1'"
+        ]
+      )
+    end
+
+    describe 'during a customized install' do
+
+      before do
+        @installer = create_source @source do
+          custom_install 'ruby setup.rb'
+        end
+
+        @installer.defaults(@deployment)
+      end
+
+      it 'should store the custom install commands' do
+        @installer.options[:custom_install].should == 'ruby setup.rb'
+      end
+      
+      it 'should identify as having a custom install command' do
+        @installer.should be_custom_install
+      end
+
+      it 'should not configure the source automatically' do
+        @installer.should_receive(:configure).and_return([])
+      end
+
+      it 'should not build the source automatically' do
+        @installer.should_receive(:build).and_return([])
+      end
+
+      it 'should install the source using a custom installation command' do
+        @installer.send(:custom_install_commands).first.should =~ /ruby setup.rb/
+      end
+      
+      it 'should be run relative to the source build area' do
+        @installer.send(:custom_install_commands).first.should =~ %r{cd /usr/builds/ruby-1.8.6-p111}
+      end
+      
+      describe 'with a customized directory' do
+        
+        before do
+          @installer.options[:custom_dir] = 'test'
+        end
+        
+        it 'should install the source from the custom dir path' do
+          @installer.send(:custom_install_commands).first.should =~ /test/
+        end
+        
+        it 'should store the custom build dir path' do
+          @installer.options[:custom_dir].should == 'test'
+        end
+        
+      end
+
+    end
+
+    after do
+      @installer.send :install_sequence
+    end
+
+  end
+
+  describe 'pre stage commands' do
+
+    before do
+      @commands = {
+        :prepare   => %w( prepare1 prepare2 ),
+        :download  => %w( down1 down2 ),
+        :extract   => %w( ex1 ex2 ),
+        :configure => %w( conf1 conf2 ),
+        :build     => %w( build1 build2 ),
+        :install   => %w( install1 install2 )
+      }
+
+      @installer = create_source @source
+      @commands.each { |k, v| @installer.pre k, *v }
+      @installer.defaults(@deployment)
+    end
+
+    it 'should run all pre-prepare commands' do
+      @commands.each { |k, v| @installer.should_receive(:pre_commands).with(k).and_return(v) }
+    end
+
+    it 'should be run relative to the source build area' do
+      @commands.each { |stage, command| @installer.send(:pre_commands, stage).first.should =~ %r{cd /usr/builds/ruby-1.8.6-p111} }
+    end
+
+    after do
+      @installer.send :install_sequence
+    end
+
+  end
+
+  describe 'post stage commands' do
+
+    before do
+      @commands = {
+        :prepare   => %w( prepare1 prepare2 ),
+        :download  => %w( down1 down2 ),
+        :extract   => %w( ex1 ex2 ),
+        :configure => %w( conf1 conf2 ),
+        :build     => %w( build1 build2 ),
+        :install   => %w( install1 install2 )
+      }
+
+      @installer = create_source @source
+      @commands.each { |k, v| @installer.post k, *v }
+      @installer.defaults(@deployment)
+    end
+
+    it 'should run all post-prepare commands' do
+      @commands.each { |k, v| @installer.should_receive(:post_commands).with(k).and_return(v) }
+    end
+
+    it 'should be run relative to the source build area' do
+      @commands.each { |stage, command| @installer.send(:post_commands, stage).first.should =~ %r{cd /usr/builds/ruby-1.8.6-p111} }
+    end
+
+    after do
+      @installer.send :install_sequence
+    end
+
+  end
+
+  describe 'install sequence' do
+
+    it 'should prepare, then download, then extract, then configure, then build, then install' do
+      %w( prepare download extract configure build install ).each do |stage|
+        @installer.should_receive(stage).ordered.and_return([])
+      end
+    end
+
+    after do
+      @installer.send :install_sequence
+    end
+
+  end
+
+  describe 'source extraction' do
+
+    it 'should support tgz archives' do
+      @installer.source = 'blah.tgz'
+      @extraction = 'tar xzf'
+    end
+
+    it 'should support tar.gz archives' do
+      @installer.source = 'blah.tgz'
+      @extraction = 'tar xzf'
+    end
+
+    it 'should support tar.bz2 archives' do
+      @installer.source = 'blah.tar.bz2'
+      @extraction = 'tar xjf'
+    end
+
+    it 'should support tb2 archives' do
+      @installer.source = 'blah.tb2'
+      @extraction = 'tar xjf'
+    end
+
+    it 'should support zip archives' do
+      @installer.source = 'blah.zip'
+      @extraction = 'unzip'
+    end
+
+    after do
+      @installer.send(:extract_command).should == @extraction
+    end
+
+  end
+
+end

data/spec/sprinkle/package_spec.rb

@@ -0,0 +1,422 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Sprinkle::Package do
+  include Sprinkle::Package
+
+  before do
+    @name = :package_name
+    @empty = Proc.new { }
+    @opts = { }
+  end
+  
+  # Kind of a messy way to do this but it works and DRYs out
+  # the specs. Checks to make sure an installer is receiving
+  # the block passed to it throught the package block.
+  def check_block_forwarding_on(installer)
+    eval(<<CODE)
+    pre_count = 0
+    lambda {
+      pkg = package @name do
+        #{installer} 'archive' do
+          pre :install, 'preOp'
+        end
+      end
+      
+      pre_count = pkg.installer.instance_variable_get(:@pre)[:install].length
+    }.should change { pre_count }.by(1)
+CODE
+  end
+  
+  # More of Mitchell's meta-programming to dry up specs.
+  def create_package_with_blank_verify(n = 1)
+    eval(<<CODE)
+    @pkg = package @name do
+      gem 'gem'
+      #{"verify 'stuff happens' do; end\n" * n}
+    end
+CODE
+  end
+
+  describe 'when created' do
+
+    it 'should be invalid without a block descriptor' do
+      lambda { package @name }.should raise_error
+    end
+
+    it 'should be invalid without a name' do
+      lambda { package nil, &@empty }.should raise_error
+      lambda { package @name, &@empty }.should_not raise_error
+    end
+
+    it 'should optionally accept a description' do
+      pkg = package @name do
+        description 'my package description'
+      end
+      pkg.description.should == 'my package description'
+    end
+
+    it 'should optionally accept a version' do
+      pkg = package @name do
+        version '2.0.2'
+      end
+      pkg.version.should == '2.0.2'
+    end
+
+    it 'should optionally accept an installer' do
+      pkg = package @name do
+        gem 'rails'
+      end
+      pkg.installer.should_not be_nil
+    end
+
+    it 'should optionally accept dependencies' do
+      pkg = package @name do
+        requires :webserver, :database
+      end
+      pkg.dependencies.should == [:webserver, :database]
+    end
+
+    it 'should optionally accept recommended dependencies' do
+      pkg = package @name do
+        recommends :webserver, :database
+      end
+      pkg.recommends.should == [:webserver, :database]
+    end
+
+    it 'should optionally define a virtual package implementation' do
+      pkg = package @name, :provides => :database do; end
+      pkg.provides.should == :database
+    end
+
+    it 'should be able to represent itself as a string' do
+      pkg = package @name do; end
+      pkg.to_s.should == @name
+    end
+
+  end
+
+  describe 'helper method' do
+
+    it 'should added new packages to the global package hash' do
+      pkg = package @name do; end
+      Sprinkle::Package::PACKAGES[@name].should == pkg
+    end
+
+    it 'should add the new package to the provides list if specified' do
+      pkg = package @name, :provides => :database do; end
+      Sprinkle::Package::PACKAGES[:database].last.should == pkg
+    end
+
+  end
+
+  describe 'installer configuration' do
+
+    it 'should optionally accept an apt installer' do
+      pkg = package @name do
+        apt %w( deb1 deb2 )
+      end
+      pkg.should respond_to(:apt)
+      pkg.installer.class.should == Sprinkle::Installers::Apt
+    end
+
+    it 'should optionally accept an rpm installer' do
+      pkg = package @name do
+        rpm %w( rpm1 rpm2 )
+      end
+      pkg.should respond_to(:rpm)
+      pkg.installer.class.should == Sprinkle::Installers::Rpm
+    end
+
+    it 'should optionally accept a gem installer' do
+      pkg = package @name do
+        gem 'gem'
+      end
+      pkg.should respond_to(:gem)
+      pkg.installer.class.should == Sprinkle::Installers::Gem
+    end
+
+    it 'should optionally accept a source installer' do
+      pkg = package @name do
+        source 'archive'
+      end
+      pkg.should respond_to(:source)
+      pkg.installer.class.should == Sprinkle::Installers::Source
+    end
+
+  end
+
+  describe 'with a source installer' do
+
+    it 'should optionally accept a block containing customisations' do
+      pkg = package @name do
+        source 'archive' do; end
+      end
+      pkg.should respond_to(:source)
+      pkg.installer.class.should == Sprinkle::Installers::Source
+    end
+    
+    it 'should forward block to installer superclass' do
+      check_block_forwarding_on(:source)
+    end
+
+    it 'should automatically add a build essential recommendation' do
+      pkg = package @name do
+        source 'archive'
+      end
+      pkg.recommends.should include(:build_essential)
+    end
+
+  end
+  
+  describe 'with an apt installer' do
+    it 'should forward block to installer superclass' do
+      check_block_forwarding_on(:apt)
+    end
+  end
+  
+  describe 'with an rpm installer' do
+    it 'should forward block to installer superclass' do
+      check_block_forwarding_on(:rpm)
+    end
+  end
+
+  describe 'with an gem installer' do
+
+    it 'should automatically add a rubygems recommendation' do
+      pkg = package @name do
+        gem 'gem'
+      end
+      pkg.recommends.should include(:rubygems)
+    end
+    
+    it 'should forward block to installer superclass' do
+      check_block_forwarding_on(:gem)
+    end
+
+  end
+
+  describe 'when processing' do
+
+    before do
+      @deployment = mock(Sprinkle::Deployment)
+      @roles = [ :app, :db ]
+      @installer = mock(Sprinkle::Installers::Installer, :defaults => true, :process => true)
+      @package = package @name do; end
+    end
+
+    describe 'with an installer' do
+
+      before do
+        @package.installer = @installer
+      end
+
+      it 'should configure itself against the deployment context' do
+        @installer.should_receive(:defaults).with(@deployment).and_return
+      end
+
+      it 'should request the installer to process itself' do
+        @installer.should_receive(:process).with(@roles).and_return
+      end
+
+      after do
+        @package.process(@deployment, @roles)
+      end
+    end
+
+    describe 'without an installer' do
+
+      it 'should not request the installer to process if the package is a metapackage' do
+        @installer.should_not_receive(:process)
+        @package.process(@deployment, @roles)
+      end
+
+    end
+    
+    describe 'with verifications' do
+      before do
+        @pkg = create_package_with_blank_verify(3)
+        @pkg.installer = @installer
+        @installer.stub!(:defaults)
+        @installer.stub!(:process)
+      end
+      
+      describe 'with forcing' do
+        before do
+          # Being explicit
+          Sprinkle::OPTIONS[:force] = true
+        end
+        
+        it 'should process verifications only once' do
+          @pkg.should_receive(:process_verifications).once
+          @pkg.process(@deployment, @roles)
+        end
+        
+        after do
+          # Being explicit
+          Sprinkle::OPTIONS[:force] = false
+        end
+      end
+      
+      describe 'without forcing' do
+        before do
+          # Being explicit
+          Sprinkle::OPTIONS[:force] = false
+        end
+        
+        it 'should process verifications twice' do
+          @pkg.should_receive(:process_verifications).once.with(@deployment, @roles, true).and_raise(Sprinkle::VerificationFailed.new(@pkg, ''))
+          @pkg.should_receive(:process_verifications).once.with(@deployment, @roles).and_raise(Sprinkle::VerificationFailed.new(@pkg, ''))
+        end
+        
+        it 'should continue with installation if pre-verification fails' do
+          @pkg.should_receive(:process_verifications).twice.and_raise(Sprinkle::VerificationFailed.new(@pkg, ''))
+          @installer.should_receive(:defaults)
+          @installer.should_receive(:process)
+        end
+        
+        it 'should only process verifications once and should not process installer if verifications succeed' do
+          @pkg.should_receive(:process_verifications).once.and_return(nil)
+          @installer.should_not_receive(:defaults)
+          @installer.should_not_receive(:process)
+        end
+        
+        after do
+          begin
+            @pkg.process(@deployment, @roles)
+          rescue Sprinkle::VerificationFailed => e; end
+        end
+      end
+    end
+
+  end
+  
+  describe 'when processing verifications' do
+    before do
+      @deployment = mock(Sprinkle::Deployment)
+      @roles = [ :app, :db ]
+      @installer = mock(Sprinkle::Installers::Installer, :defaults => true, :process => true)
+      @pkg = create_package_with_blank_verify(3)
+      @pkg.installer = @installer
+      @installer.stub!(:defaults)
+      @installer.stub!(:process)
+      @logger = mock(ActiveSupport::BufferedLogger, :debug => true, :debug? => true)
+      @logger.stub!(:info)
+    end
+    
+    it 'should request _each_ verification to configure itself against the deployment context' do
+      @pkg.verifications.each do |v|
+        v.should_receive(:defaults).with(@deployment).once
+        v.stub!(:process)
+      end
+    end
+
+    it 'should request _each_ verification to process' do
+      @pkg.verifications.each do |v|
+        v.stub!(:defaults)
+        v.should_receive(:process).with(@roles).once
+      end
+    end
+    
+    it 'should enter a log info event to notify user whats happening' do
+      @pkg.verifications.each do |v|
+        v.stub!(:defaults)
+        v.stub!(:process)
+      end
+      
+      @pkg.should_receive(:logger).once.and_return(@logger)
+    end
+    
+    after do
+      @pkg.process_verifications(@deployment, @roles)
+    end
+  end
+
+  describe 'hierarchies' do
+
+    before do
+      @a = package :a do; requires :b; end
+      @b = package :b do; requires :c; end
+      @c = package :c do; recommends :d; end
+      @d = package :d do; end
+    end
+
+    it 'should be able to return a dependency hierarchy tree' do
+      @a.tree.flatten.should == [ @d, @c, @b, @a ]
+      @b.tree.flatten.should == [ @d, @c, @b ]
+      @c.tree.flatten.should == [ @d, @c ]
+      @d.tree.flatten.should == [ @d ]
+    end
+
+    describe 'with missing recommendations' do
+
+      before do
+        @d.recommends :e
+      end
+
+      it 'should ignore missing recommendations' do
+        @d.tree.flatten.should == [ @d ]
+      end
+
+    end
+
+    it 'should optionally accept a block to call upon item in the tree during hierarchy traversal' do
+      @count = 0
+      @a.tree do
+        @count += 1
+      end
+      @count.should == 3
+    end
+
+    it 'should maintain a depth count of how deep the hierarchy is' do
+      @b.should_receive(:tree).with(2).and_return([@b])
+      @a.tree do; end
+    end
+
+  end
+
+  describe 'with missing dependencies' do
+
+    before do
+      @pkg = package @name do
+        gem 'gem'
+        requires :missing
+      end
+    end
+
+    it 'should raise an error if a package is missing' do
+      lambda { @pkg.tree }.should raise_error
+    end
+
+  end
+  
+  describe 'with verifications' do    
+    it 'should create a Sprinkle::Verification object for the verify block' do
+      Sprinkle::Verify.should_receive(:new).once
+      
+      create_package_with_blank_verify
+    end
+    
+    it 'should create multiple Sprinkle::Verification objects for multiple verify blocks' do
+      Sprinkle::Verify.should_receive(:new).twice
+      
+      create_package_with_blank_verify(2)
+    end
+    
+    it 'should add each Sprinkle::Verificaton object to the @verifications array' do
+      @pkg = create_package_with_blank_verify(3)
+      @pkg.verifications.length.should eql(3)
+    end
+    
+    it 'should initialize Sprinkle::Verification with the package name, description, and block' do
+      Sprinkle::Verify.should_receive(:new) do |pkg, desc|
+        pkg.name.should eql(@name)
+        desc.should eql('stuff happens')
+      end
+      
+      # We do a should_not raise_error because if a block was NOT passed, an error
+      # is raised. This is specced in verification_spec.rb
+      lambda { create_package_with_blank_verify }.should_not raise_error
+    end
+  end
+
+end