jemmyw-sprinkle 0.2.3

data/spec/sprinkle/package_spec.rb

@@ -0,0 +1,452 @@
+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, binding, __FILE__, __LINE__)
+    pre_count = 0
+    lambda {
+      pkg = package @name do
+        #{installer} 'archive' do
+          pre :install, 'preOp'
+        end
+      end
+      
+      pre_count = pkg.operations.last.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, binding, __FILE__, __LINE__)
+    @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.operations.last.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.operations.last.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.operations.last.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.operations.last.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.operations.last.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.operations.last.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 'with a custom installer' do
+    it 'should forward block to installer superclass' do
+      check_block_forwarding_on(:custom)
+    end
+  end
+
+  describe 'when processing' do
+
+    before do
+      @deployment = mock(Sprinkle::Deployment)
+      @roles = [ :app, :db ]
+      @installer = mock(Sprinkle::Installers::Installer, :defaults => true, :process => true, :responds_to? => true)
+      @package = package @name do; end
+    end
+
+    describe 'with an installer' do
+
+      before do
+        @package.operations = [@installer]
+      end
+
+      it 'should configure itself against the deployment context' do
+        @installer.should_receive(:defaults).with(@deployment).and_return
+        @deployment.should_receive(:find_servers).with(:app).and_return(['app1.example.com'])
+        @deployment.should_receive(:find_servers).with(:db).and_return(['db1.example.com'])        
+      end
+
+      it 'should request the installer to process itself' do
+        @installer.should_receive(:process).with('app1.example.com').and_return
+        @installer.should_receive(:process).with('db1.example.com').and_return
+        @deployment.should_receive(:find_servers).with(:app).and_return(['app1.example.com'])
+        @deployment.should_receive(:find_servers).with(:db).and_return(['db1.example.com'])  
+      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.operations = [@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).twice
+          @deployment.should_receive(:find_servers).with(:app).and_return(['app1.example.com'])  
+          @deployment.should_receive(:find_servers).with(:db).and_return(['db1.example.com'])  
+          @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, 'app1.example.com', true).and_raise(Sprinkle::VerificationFailed.new(@pkg, ''))
+          @pkg.should_receive(:process_verifications).once.with(@deployment, 'app1.example.com').and_raise(Sprinkle::VerificationFailed.new(@pkg, ''))
+          @deployment.should_receive(:find_servers).with(:app).and_return(['app1.example.com'])  
+        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)
+          @deployment.should_receive(:find_servers).with(:app).and_return(['app1.example.com'])  
+        end
+        
+        it 'should only process verifications once and should not process installer if verifications succeed' do
+          @pkg.should_receive(:process_verifications).twice.and_return(nil)
+          @installer.should_not_receive(:defaults)
+          @installer.should_not_receive(:process)
+          @deployment.should_receive(:find_servers).with(:app).and_return(['app1.example.com'])          
+          @deployment.should_receive(:find_servers).with(:db).and_return(['db1.example.com'])               
+        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.operations << @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 'virtual package dependencies' do
+    before do
+      @a = package :a do; requires :virtual ; end
+      @v1 = package :v1, :provides => :virtual do; end
+      @v2 = package :v2, :provides => :virtual do; end
+    end
+    
+    it 'should select package for an array' do
+      @a.should_receive(:select_package).with(:virtual, [@v1,@v2]).and_return(@v1)
+      @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

data/spec/sprinkle/policy_spec.rb

@@ -0,0 +1,133 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Sprinkle::Policy do
+  include Sprinkle::Policy
+
+  before do
+    @name = 'a policy'
+  end
+
+  describe 'when created' do
+
+    it 'should be invalid without a name' do
+      lambda { policy nil }.should raise_error
+    end
+
+    it 'should be invalid without role definitions' do
+      lambda { policy @name do; end }.should raise_error
+      lambda { policy @name, :roles => :app do; end }.should_not raise_error
+    end
+
+    it 'should optionally accept package dependencies' do
+      p = policy @name, :roles => :app do; end
+      p.should respond_to(:requires)
+      p.requires :appserver
+      p.packages.should == [ :appserver ]
+    end
+    
+    it 'should accept package dependencies using the configures alias' do
+      p = policy @name, :roles => :app do; end
+      p.should respond_to(:configures)
+      p.configures :appserver
+      p.packages.should == [ :appserver ]
+    end
+
+    it 'should optionally accept package dependencies with versions' do
+      p = policy @name, :roles => :app do; end
+      p.requires :appserver, :version => 2
+      p.packages.should == [ :appserver ]
+      pending 'requires version checking implementation'
+    end
+
+    it 'should add itself to the global policy list' do
+      sz = Sprinkle::Policy::POLICIES.size
+      p = policy @name, :roles => :app do; end
+      Sprinkle::Policy::POLICIES.size.should == sz + 1
+      Sprinkle::Policy::POLICIES.last.should == p
+    end
+
+  end
+
+  describe 'with packages' do
+    include Sprinkle::Package
+
+    before do
+      @deployment = mock(Sprinkle::Deployment)
+      Sprinkle::Package::PACKAGES.clear # reset full package list before each spec is run
+
+      @a = package :a do; requires :b; requires :c; end
+      @b = package :b, :provides => :xyz do; end
+      @c = package :c, :provides => :abc do; end
+      @d = package :d, :provides => :abc do; end
+
+      @policy = policy :test, :roles => :app do; requires :a; end
+      $terminal.stub!(:choose).and_return(:c) # stub out highline asking questions
+    end
+
+    describe 'when applying' do
+      include Sprinkle::Package
+
+      it 'should determine the packages to install via the hierarchy dependency tree of each package in the policy' do
+        @a.should_receive(:process).and_return
+        @b.should_receive(:process).and_return
+        @c.should_receive(:process).and_return
+        @d.should_not_receive(:process)
+      end
+
+      it 'should normalize (ie remove duplicates from) the installation order of all packages including dependencies' do
+        @e = package :e do; requires :b; end
+        @policy.requires :e
+
+        @a.should_receive(:process).once.and_return
+        @b.should_receive(:process).once.and_return
+        @c.should_receive(:process).once.and_return
+        @d.should_not_receive(:process)
+        @e.should_receive(:process).once.and_return
+      end
+    end
+
+    describe 'containing package dependencies with versions' do
+
+      it 'should be invalid if the specified package does not exist'
+      it 'should ignore any packages of the same name that have other versions'
+      it 'should select the correct package version when applying'
+
+    end
+
+    describe 'containing virtual packages' do
+
+      it 'should automatically select a concrete package implementation for a virtual one when there exists only one possible selection' do
+        @policy = policy :virtual, :roles => :app do; requires :xyz; end
+        Sprinkle::Package::PACKAGES[:xyz].should == [ @b ]
+      end
+
+      it 'should ask the user for the concrete package implementation to use for a virtual one when more than one possible choice exists' do
+        @policy = policy :virtual, :roles => :app do; requires :abc; end
+        Sprinkle::Package::PACKAGES[:abc].should include(@c)
+        Sprinkle::Package::PACKAGES[:abc].should include(@d)
+        $terminal.should_receive(:choose).and_return(:c)
+      end
+
+    end
+
+    after do
+      @policy.process(@deployment)
+    end
+  end
+end
+
+describe Sprinkle::Policy, 'with missing packages' do
+
+  before do
+    @deployment = mock(Sprinkle::Deployment)
+    Sprinkle::Package::PACKAGES.clear # reset full package list before each spec is run
+
+    @policy = policy :test, :roles => :app do; requires :z; end
+    $terminal.stub!(:choose).and_return(:c) # stub out highline asking questions
+  end
+
+  it 'should raise an error if a package is missing' do
+    lambda { @policy.process(@deployment) }.should raise_error
+  end
+
+end

data/spec/sprinkle/script_spec.rb

@@ -0,0 +1,51 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Sprinkle::Script, 'class' do
+  
+  it 'should define a entry point into the system' do
+    Sprinkle::Script.should respond_to(:sprinkle)
+  end
+  
+end
+
+describe Sprinkle::Script, 'when given a script' do
+  
+  before do
+    @script = 'script'
+    @filename = 'filename'
+    
+    @sprinkle = Sprinkle::Script.new
+    Sprinkle::Script.stub!(:new).and_return(@sprinkle)
+  end
+
+  it 'should create a new sprinkle instance' do
+    Sprinkle::Script.should_receive(:new).and_return(@sprinkle)
+    Sprinkle::Script.sprinkle @script
+  end
+  
+  it 'should evaulate the sprinkle script against the instance' do
+    @sprinkle.should_receive(:instance_eval).and_return
+    Sprinkle::Script.sprinkle @script
+  end
+  
+  it 'should specify the filename if given for line number errors' do 
+    @sprinkle.should_receive(:instance_eval).with(@script, @filename).and_return
+    Sprinkle::Script.sprinkle @script, @filename
+  end
+  
+  it 'should specify a filename of __SCRIPT__ by default if none is provided' do 
+    @sprinkle.should_receive(:instance_eval).with(@script, '__SCRIPT__').and_return
+    Sprinkle::Script.sprinkle @script
+  end
+  
+  it 'should automatically run in production mode by default' do
+    @sprinkle.should_receive(:instance_eval).with(@script, '__SCRIPT__').and_return
+    Sprinkle::Script.sprinkle @script
+  end
+  
+  it 'should ask the Sprinkle instance to process the data from the script' do
+    @sprinkle.should_receive(:sprinkle)
+    Sprinkle::Script.sprinkle @script
+  end
+  
+end

data/spec/sprinkle/sprinkle_spec.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Sprinkle do
+
+  it 'should automatically extend Object to support package, policy and deployment DSL keywords' do
+    %w( package policy deployment ).each do |keyword|
+      Object.should respond_to(keyword.to_sym)
+    end
+  end
+
+  it 'should default to production mode' do
+    Sprinkle::OPTIONS[:testing].should be_false
+  end
+
+  it 'should automatically create a logger object on Kernel' do
+    Object.should respond_to(:logger)
+    logger.should_not be_nil
+    logger.class.should == ActiveSupport::BufferedLogger
+  end
+
+  it 'should create a logger of level INFO' do
+    logger.level.should == ActiveSupport::BufferedLogger::Severity::INFO
+  end
+
+end