dpkg-tools 0.3.3 → 0.3.4

data/resources/rails/preinst.erb

@@ -0,0 +1,36 @@
+#!/bin/bash -e
+
+DATADIR="<%= app_install_path %>"
+
+# Create a group for the app if it isn't already there
+if ! getent group "<%= name %>" >/dev/null; then
+	# Adding system group for the app: <%= name %>.
+	addgroup --system "<%= name %>" >/dev/null
+fi
+
+# Create a user for the app if it isn't already there
+if ! getent passwd <%= name %> >/dev/null; then
+	# Adding system user: <%= name %>.
+	adduser \
+	  --system \
+	  --disabled-login \
+	  --ingroup <%= name %> \
+	  --home $DATADIR \
+	  --gecos "<%= name %> Rails app" \
+	  --shell /bin/bash \
+	  <%= name %>  >/dev/null
+fi
+
+# Create the app's home dir, if it isn't there already...
+if [ ! -d $DATADIR -a ! -L $DATADIR ]; then
+ 	mkdir -p $DATADIR
+fi
+
+# Fix ownership of the app's home dir...
+# The "set +e" is necessary as e.g. a ".journal" of a ext3 partition is
+# not chgrp'able (#318435). [nicked from mysql-server 5's preinst]
+set +e
+chown <%= name %>:<%= name %> $DATADIR
+find $DATADIR -follow -not -group "<%= name %>" -print0 2>/dev/null \
+  | xargs -0 --no-run-if-empty chgrp "<%= name %>"
+set -e

data/spec/dpkg-tools/package/builder_spec.rb

@@ -1,159 +1,176 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
-describe DpkgTools::Package::Builder, "instances" do
-  before(:each) do
-    DpkgTools::Package::Config.stubs(:root_path).returns('/a/path/to/')
-    @config = DpkgTools::Package::Config.new('rails-app', '1.0.8', {})
-    DpkgTools::Package::Config.expects(:new).with('rails-app', '1.0.8', {}).returns(@config)
-    
-    @stub_data = stub("stub DpkgTools::Package::Rails::Data", :name => 'rails-app', :version => '1.0.8',
-                 :full_name => 'rails-app-1.0.8', :debian_revision => "1", :debian_arch => "all",
-                 :mongrel_ports => ['8000', '8001', '8002'])
-    stub_data_binding = @stub_data.send(:binding)
-    @stub_data.stubs(:binding).returns(stub_data_binding)
-    
-    @builder = DpkgTools::Package::Builder.new(@stub_data)
+describe DpkgTools::Package::Builder do
+  describe ".from_path support methods" do
+    it "should provide a for-overriding method to return the Package::Data subclass to use" do
+      DpkgTools::Package::Builder.data_class.should == DpkgTools::Package::Data
+    end
   end
   
-  it "should provide access to @data" do
-    @builder.data.should == @stub_data
+  describe ".from_path" do
+    it "should be able to grab all needed config stuff and create a Data and a Builder instance" do
+      DpkgTools::Package::Data.expects(:new).with('/path/to/app').returns(:data)
+      DpkgTools::Package::Builder.expects(:new).with(:data).returns(:instance)
+                      
+      DpkgTools::Package::Builder.from_path('/path/to/app').should == :instance
+    end
   end
   
-  it "should be able to provide access to its DpkgTools::Package::Config entry" do
-    @builder.config.should == @config
-  end
+  describe "instances" do
+    before(:each) do
+      DpkgTools::Package::Config.stubs(:root_path).returns('/a/path/to/')
+      @config = DpkgTools::Package::Config.new('rails-app', '1.0.8', {})
+      DpkgTools::Package::Config.expects(:new).with('rails-app', '1.0.8', {}).returns(@config)
+    
+      @stub_data = stub("stub DpkgTools::Package::Rails::Data", :name => 'rails-app', :version => '1.0.8',
+                   :full_name => 'rails-app-1.0.8', :debian_revision => "1", :debian_arch => "all",
+                   :mongrel_ports => ['8000', '8001', '8002'])
+      stub_data_binding = @stub_data.send(:binding)
+      @stub_data.stubs(:binding).returns(stub_data_binding)
+    
+      @builder = DpkgTools::Package::Builder.new(@stub_data)
+    end
+  
+    it "should provide access to @data" do
+      @builder.data.should == @stub_data
+    end
+  
+    it "should be able to provide access to its DpkgTools::Package::Config entry" do
+      @builder.config.should == @config
+    end
   
-  it "should be able to create an intermediate tmp build directory" do
-    @builder.expects(:create_dir_if_needed).with('/a/path/to/rails-app-1.0.8/dpkg-tools-tmp')
+    it "should be able to create an intermediate tmp build directory" do
+      @builder.expects(:create_dir_if_needed).with('/a/path/to/rails-app-1.0.8/dpkg-tools-tmp')
     
-    @builder.create_intermediate_buildroot
-  end
+      @builder.create_intermediate_buildroot
+    end
   
-  it "should be able to create the debian/tmp buildroot dir" do
-    @builder.expects(:create_dir_if_needed).with('/a/path/to/rails-app-1.0.8/debian/tmp')
+    it "should be able to create the debian/tmp buildroot dir" do
+      @builder.expects(:create_dir_if_needed).with('/a/path/to/rails-app-1.0.8/debian/tmp')
     
-    @builder.create_buildroot
-  end
+      @builder.create_buildroot
+    end
   
-  it "should be able to create the buildroot/DEBIAN dir" do
-    Dir.expects(:mkdir).with('/a/path/to/rails-app-1.0.8/debian/tmp/DEBIAN')
-    File.expects(:directory?).with('/a/path/to/rails-app-1.0.8/debian/tmp/DEBIAN').returns(false)
+    it "should be able to create the buildroot/DEBIAN dir" do
+      Dir.expects(:mkdir).with('/a/path/to/rails-app-1.0.8/debian/tmp/DEBIAN')
+      File.expects(:directory?).with('/a/path/to/rails-app-1.0.8/debian/tmp/DEBIAN').returns(false)
     
-    @builder.create_DEBIAN_dir
-  end
+      @builder.create_DEBIAN_dir
+    end
   
-  it "should be able to create the DEBIAN/* package metadata files" do
-    @builder.expects(:sh).with('dpkg-gencontrol')
+    it "should be able to create the DEBIAN/* package metadata files" do
+      @builder.expects(:sh).with('dpkg-gencontrol')
     
-    @builder.create_control_files
-  end
+      @builder.create_control_files
+    end
   
-  it "should be able to generate the path to the built .deb package" do
-    @builder.built_deb_path.should == "/a/path/to/rails-app_1.0.8-1_all.deb"
-  end
+    it "should be able to generate the path to the built .deb package" do
+      @builder.built_deb_path.should == "/a/path/to/rails-app_1.0.8-1_all.deb"
+    end
   
-  it "should be able to create the .deb package" do
-    @builder.stubs(:built_deb_path).returns('/a/path/to/rails-app_1.0.8-1_all.deb')
+    it "should be able to create the .deb package" do
+      @builder.stubs(:built_deb_path).returns('/a/path/to/rails-app_1.0.8-1_all.deb')
     
-    @builder.expects(:sh).with('dpkg-deb --build "/a/path/to/rails-app-1.0.8/debian/tmp" "/a/path/to/rails-app_1.0.8-1_all.deb"')
-    @builder.create_deb
-  end
+      @builder.expects(:sh).with('dpkg-deb --build "/a/path/to/rails-app-1.0.8/debian/tmp" "/a/path/to/rails-app_1.0.8-1_all.deb"')
+      @builder.create_deb
+    end
   
-  it "should be able to report which maintainer scripts need to be generated" do
-    Dir.expects(:entries).with('/a/path/to/rails-app-1.0.8/debian').returns(['.', '..', 'postinst.erb', 'preinst.erb', 'postinst'])
-    @builder.maintainer_script_targets.should == ['postinst', 'preinst']
-  end
+    it "should be able to report which maintainer scripts need to be generated" do
+      Dir.expects(:entries).with('/a/path/to/rails-app-1.0.8/debian').returns(['.', '..', 'postinst.erb', 'preinst.erb', 'postinst'])
+      @builder.maintainer_script_targets.should == ['postinst', 'preinst']
+    end
   
-  it "should be able to render an erb template using data as the binding" do
-    @builder.render_template("<%= mongrel_ports.inspect %>").
-      should == '["8000", "8001", "8002"]'
-  end
+    it "should be able to render an erb template using data as the binding" do
+      @builder.render_template("<%= mongrel_ports.inspect %>").
+        should == '["8000", "8001", "8002"]'
+    end
   
-  it "should be able to generate a maintainer script" do
-    File.expects(:read).with('/a/path/to/rails-app-1.0.8/debian/postinst.erb').returns('template')
-    mock_file = mock('File')
-    mock_file.expects(:write).with('rendered template')
-    File.expects(:open).with('/a/path/to/rails-app-1.0.8/debian/tmp/DEBIAN/postinst', 'w').yields(mock_file)
-    File.expects(:chmod).with(0755, '/a/path/to/rails-app-1.0.8/debian/tmp/DEBIAN/postinst')
+    it "should be able to generate a maintainer script" do
+      File.expects(:read).with('/a/path/to/rails-app-1.0.8/debian/postinst.erb').returns('template')
+      mock_file = mock('File')
+      mock_file.expects(:write).with('rendered template')
+      File.expects(:open).with('/a/path/to/rails-app-1.0.8/debian/tmp/DEBIAN/postinst', 'w').yields(mock_file)
+      File.expects(:chmod).with(0755, '/a/path/to/rails-app-1.0.8/debian/tmp/DEBIAN/postinst')
     
-    @builder.expects(:render_template).with('template').returns('rendered template')
+      @builder.expects(:render_template).with('template').returns('rendered template')
     
-    @builder.generate_maintainer_script('postinst')
-  end
+      @builder.generate_maintainer_script('postinst')
+    end
   
-  it "should be able to generate all the maintainer scripts" do
-    @builder.expects(:maintainer_script_targets).returns(['postinst', 'preinst'])
-    @builder.expects(:generate_maintainer_script).with('postinst')
-    @builder.expects(:generate_maintainer_script).with('preinst')
+    it "should be able to generate all the maintainer scripts" do
+      @builder.expects(:maintainer_script_targets).returns(['postinst', 'preinst'])
+      @builder.expects(:generate_maintainer_script).with('postinst')
+      @builder.expects(:generate_maintainer_script).with('preinst')
     
-    @builder.generate_maintainer_scripts
-  end 
+      @builder.generate_maintainer_scripts
+    end 
   
-  it "should be able to report that it's an architecture independent package when it is" do
-    @stub_data.stubs(:architecture_independent?).returns(true)
-    @builder.architecture_independent?.should be_true
-  end
+    it "should be able to report that it's an architecture independent package when it is" do
+      @stub_data.stubs(:architecture_independent?).returns(true)
+      @builder.architecture_independent?.should be_true
+    end
   
-  it "should be able to report that it's an architecture dependent package when it is" do
-    @stub_data.stubs(:architecture_independent?).returns(false)
-    @builder.architecture_independent?.should be_false
+    it "should be able to report that it's an architecture dependent package when it is" do
+      @stub_data.stubs(:architecture_independent?).returns(false)
+      @builder.architecture_independent?.should be_false
+    end
   end
-end
 
-describe DpkgTools::Package::Builder, "#build_package" do
-  it "should perform the equivalent steps to configure/make" do
-    stub_data = stub("stub DpkgTools::Package::Gem::Data", :name => 'rails-app', :version => '1.0.8', 
-                 :full_name => 'rails-app-1.0.8')
-    builder = DpkgTools::Package::Builder.new(stub_data)
-    builder.expects(:create_buildroot)
-    builder.expects(:create_install_dirs)
-    builder.expects(:build_package_files)
-    
-    builder.build_package
+  describe DpkgTools::Package::Builder, "#build_package" do
+    it "should perform the equivalent steps to configure/make" do
+      stub_data = stub("stub DpkgTools::Package::Gem::Data", :name => 'rails-app', :version => '1.0.8', 
+                   :full_name => 'rails-app-1.0.8')
+      builder = DpkgTools::Package::Builder.new(stub_data)
+      builder.expects(:create_buildroot)
+      builder.expects(:create_install_dirs)
+      builder.expects(:build_package_files)
+    
+      builder.build_package
+    end
   end
-end
 
-describe DpkgTools::Package::Builder, "#binary_package" do
-  it "should perform the steps needed to make a .deb and .dsc" do
-    stub_data = stub("stub DpkgTools::Package::Gem::Data", :name => 'rails-app', :version => '1.0.8', 
-                 :full_name => 'rails-app-1.0.8')
-    builder = DpkgTools::Package::Builder.new(stub_data)
-    builder.expects(:create_buildroot)
-    builder.expects(:create_install_dirs)
-    builder.expects(:install_package_files)
-    builder.expects(:generate_maintainer_scripts)
-    builder.expects(:create_DEBIAN_dir)
-    builder.expects(:create_control_files)
-    builder.expects(:create_deb)
-    
-    builder.binary_package
+  describe DpkgTools::Package::Builder, "#binary_package" do
+    it "should perform the steps needed to make a .deb and .dsc" do
+      stub_data = stub("stub DpkgTools::Package::Gem::Data", :name => 'rails-app', :version => '1.0.8', 
+                   :full_name => 'rails-app-1.0.8')
+      builder = DpkgTools::Package::Builder.new(stub_data)
+      builder.expects(:create_buildroot)
+      builder.expects(:create_install_dirs)
+      builder.expects(:install_package_files)
+      builder.expects(:generate_maintainer_scripts)
+      builder.expects(:create_DEBIAN_dir)
+      builder.expects(:create_control_files)
+      builder.expects(:create_deb)
+    
+      builder.binary_package
+    end
   end
-end
 
-describe DpkgTools::Package::Builder, "#remove_build_products" do
-  before(:each) do
-    DpkgTools::Package::Config.stubs(:root_path).returns("a/path/to")
+  describe DpkgTools::Package::Builder, "#remove_build_products" do
+    before(:each) do
+      DpkgTools::Package::Config.stubs(:root_path).returns("a/path/to")
     
-    @stub_data = stub("stub DpkgTools::Package::Gem::Data", :name => 'rails-app', :version => '1.0.8', 
-                 :full_name => 'rails-app-1.0.8')
+      @stub_data = stub("stub DpkgTools::Package::Gem::Data", :name => 'rails-app', :version => '1.0.8', 
+                   :full_name => 'rails-app-1.0.8')
     
-    @builder = DpkgTools::Package::Builder.new(@stub_data)
-  end
+      @builder = DpkgTools::Package::Builder.new(@stub_data)
+    end
   
-  it "should only try to remove build products when debian/tmp exists" do
-    File.expects(:exists?).with('a/path/to/rails-app-1.0.8/debian/tmp').returns(false)
-    File.expects(:exists?).with('a/path/to/rails-app-1.0.8/dpkg-tools-tmp').returns(false)
-    FileUtils.expects(:remove_dir).never
+    it "should only try to remove build products when debian/tmp exists" do
+      File.expects(:exists?).with('a/path/to/rails-app-1.0.8/debian/tmp').returns(false)
+      File.expects(:exists?).with('a/path/to/rails-app-1.0.8/dpkg-tools-tmp').returns(false)
+      FileUtils.expects(:remove_dir).never
     
-    @builder.remove_build_products
-  end
+      @builder.remove_build_products
+    end
   
-  it "should remove all the build products" do
-    File.expects(:exists?).with('a/path/to/rails-app-1.0.8/debian/tmp').returns(true)
-    FileUtils.expects(:remove_dir).with('a/path/to/rails-app-1.0.8/debian/tmp')
-    File.expects(:exists?).with('a/path/to/rails-app-1.0.8/dpkg-tools-tmp').returns(true)
-    FileUtils.expects(:remove_dir).with('a/path/to/rails-app-1.0.8/dpkg-tools-tmp')
+    it "should remove all the build products" do
+      File.expects(:exists?).with('a/path/to/rails-app-1.0.8/debian/tmp').returns(true)
+      FileUtils.expects(:remove_dir).with('a/path/to/rails-app-1.0.8/debian/tmp')
+      File.expects(:exists?).with('a/path/to/rails-app-1.0.8/dpkg-tools-tmp').returns(true)
+      FileUtils.expects(:remove_dir).with('a/path/to/rails-app-1.0.8/dpkg-tools-tmp')
     
-    @builder.remove_build_products
+      @builder.remove_build_products
+    end
   end
 end

data/spec/dpkg-tools/package/data_spec.rb

@@ -89,12 +89,21 @@ describe DpkgTools::Package::Data::YamlConfigHelpers do
         should include({:name => 'rspec-rubygem', :requirements => ['>= 1.0.8-1']})
     end
 
+    it "should be able to cope with deps without version requirements" do
+      fixture_data = {'dependencies' => {'gem' => ['rspec']}}
+
+      @module.process_dependencies(fixture_data).
+        should include({:name => 'rspec-rubygem'})
+    end
+
     it "should raise an appropriate error if the dependencies collection is not a Hash (YAML collection)" do
       fixture_data = {'dependencies' => 'string'}
 
       lambda { @module.process_dependencies(fixture_data) }.
         should raise_error(DpkgTools::Package::DebYAMLParseError)
     end
+    
+    
   end
 
   describe @module, ".process_dependencies_by_type" do

data/spec/dpkg-tools/package/etc/builder_spec.rb

@@ -1,28 +1,48 @@
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
-describe DpkgTools::Package::Etc::Builder, "instances" do
-  before(:each) do
-    @config = DpkgTools::Package::Config.new('rails-app', '1.0.8')
-    DpkgTools::Package::Etc::Data.expects(:load_package_data).with('/a/path/to/conf-package', 'deb.yml').
-      returns({'name' => 'conf-package', 'version' => '1.0.8'})
-    @data = DpkgTools::Package::Etc::Data.new('/a/path/to/conf-package')
-    
-    @builder = DpkgTools::Package::Etc::Builder.new(@data)
-  end
-  
-  it "should provide the correct options for DpkgTools::Package::Config " do
-    @builder.config_options.should == {:base_path => "/a/path/to/conf-package"}
+describe DpkgTools::Package::Etc::Builder do
+  describe ".from_path support" do
+    it "should return DpkgTools::Package::Etc::Data when asked for the data subclass to use" do
+      DpkgTools::Package::Etc::Builder.data_class.should == DpkgTools::Package::Etc::Data
+    end
   end
   
-  it "should be able to create the needed install dirs" do
-    @builder.expects(:create_dir_if_needed).with('/a/path/to/conf-package/debian/tmp/etc')
+  describe "instances" do
+    before(:each) do
+      @config = DpkgTools::Package::Config.new('rails-app', '1.0.8')
+      DpkgTools::Package::Etc::Data.expects(:load_package_data).with('/a/path/to/conf-package', 'deb.yml').
+        returns({'name' => 'conf-package', 'version' => '1.0.8'})
+      @data = DpkgTools::Package::Etc::Data.new('/a/path/to/conf-package')
     
-    @builder.create_install_dirs
-  end
+      @builder = DpkgTools::Package::Etc::Builder.new(@data)
+    end
+  
+    it "should provide the correct options for DpkgTools::Package::Config " do
+      @builder.config_options.should == {:base_path => "/a/path/to/conf-package"}
+    end
   
-  it "should copy the contents of package/etc to package/debian/tmp/etc/" do
-    FileUtils.expects(:cp_r).with('/a/path/to/conf-package/etc', '/a/path/to/conf-package/debian/tmp/etc')
+    it "should be able to create the needed install dirs" do
+      @builder.expects(:create_dir_if_needed).with('/a/path/to/conf-package/debian/tmp/etc')
     
-    @builder.install_package_files
+      @builder.create_install_dirs
+    end
+  
+    it "should copy the contents of package/etc to package/debian/tmp/etc/" do
+      Dir.expects(:[]).with('/a/path/to/conf-package/etc/**/*').returns(['/a/path/to/conf-package/etc/thing',
+                                                                         '/a/path/to/conf-package/etc/thing/conf_file',
+                                                                         '/a/path/to/conf-package/etc/thing/wotsit.yml'])
+      File.expects(:file?).with('/a/path/to/conf-package/etc/thing').returns(false)
+      File.expects(:file?).with('/a/path/to/conf-package/etc/thing/conf_file').returns(true)
+      FileUtils.expects(:mkdir_p).with('/a/path/to/conf-package/debian/tmp/etc/thing')
+      FileUtils.expects(:install).with('/a/path/to/conf-package/etc/thing/conf_file',
+                                       '/a/path/to/conf-package/debian/tmp/etc/thing/conf_file',
+                                       {:mode => 0644, :verbose => true})
+      File.expects(:file?).with('/a/path/to/conf-package/etc/thing/wotsit.yml').returns(true)
+      FileUtils.expects(:mkdir_p).with('/a/path/to/conf-package/debian/tmp/etc/thing')
+      FileUtils.expects(:install).with('/a/path/to/conf-package/etc/thing/wotsit.yml',
+                                       '/a/path/to/conf-package/debian/tmp/etc/thing/wotsit.yml',
+                                       {:mode => 0644, :verbose => true})
+      @builder.install_package_files
+    end
   end
 end

data/spec/dpkg-tools/package/rails/builder_spec.rb

@@ -1,113 +1,112 @@
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
 describe DpkgTools::Package::Rails::Builder do
-  it "should be able to grab all needed config stuff and create a DpkgTools::Package::Rails::Data and a Builder instance" do
-    DpkgTools::Package::Rails::Data.expects(:new).with('/path/to/app').returns(:data)
-    DpkgTools::Package::Rails::Builder.expects(:new).with(:data).returns(:instance)
-    
-    DpkgTools::Package::Rails::Builder.from_path('/path/to/app').should == :instance
+  describe ".from_path support" do
+    it "should return DpkgTools::Package::Rails::Data when asked for the data subclass to use" do
+      DpkgTools::Package::Rails::Builder.data_class.should == DpkgTools::Package::Rails::Data
+    end
   end
-end
-
-describe DpkgTools::Package::Rails::Builder, "instances" do
-  before(:each) do
-    @config = DpkgTools::Package::Config.new('rails-app', '1.0.8')
-    DpkgTools::Package::Rails::Data.expects(:load_package_data).with('/a/path/to/rails-app/working/dir', 'deb.yml').
-      returns({'name' => 'rails-app', 'version' => '1.0.8', 'server_name' => 'rails-app.org'}, 'mongrel_cluster' => {'port' => '8000', 'servers' => 3})
-    DpkgTools::Package::Rails::Data.expects(:load_package_data).with('/a/path/to/rails-app/working/dir', 'database.yml').
-      returns({'development' => {'database' => 'db_name'}})
-    @data = DpkgTools::Package::Rails::Data.new('/a/path/to/rails-app/working/dir')
+  
+  describe "instances" do
+    before(:each) do
+      @config = DpkgTools::Package::Config.new('rails-app', '1.0.8')
+      DpkgTools::Package::Rails::Data.expects(:load_package_data).with('/a/path/to/rails-app/working/dir', 'deb.yml').
+        returns({'name' => 'rails-app', 'version' => '1.0.8', 'server_name' => 'rails-app.org'}, 'mongrel_cluster' => {'port' => '8000', 'servers' => 3})
+      DpkgTools::Package::Rails::Data.expects(:load_package_data).with('/a/path/to/rails-app/working/dir', 'database.yml').
+        returns({'development' => {'database' => 'db_name'}})
+      @data = DpkgTools::Package::Rails::Data.new('/a/path/to/rails-app/working/dir')
     
-    @builder = DpkgTools::Package::Rails::Builder.new(@data)
-  end
+      @builder = DpkgTools::Package::Rails::Builder.new(@data)
+    end
   
-  it "should provide the correct options for DpkgTools::Package::Config " do
-    @builder.config_options.should == {:base_path => "/a/path/to/rails-app/working/dir"}
-  end
+    it "should provide the correct options for DpkgTools::Package::Config " do
+      @builder.config_options.should == {:base_path => "/a/path/to/rails-app/working/dir"}
+    end
   
-  it "should be able to create the needed install dirs" do
-    @builder.expects(:create_dir_if_needed).with('/a/path/to/rails-app/working/dir/debian/tmp/etc/init.d')
-    @builder.expects(:create_dir_if_needed).with('/a/path/to/rails-app/working/dir/debian/tmp/etc/apache2/sites-available')
-    @builder.expects(:create_dir_if_needed).with('/a/path/to/rails-app/working/dir/debian/tmp/etc/logrotate.d')
-    @builder.expects(:create_dir_if_needed).with('/a/path/to/rails-app/working/dir/debian/tmp/var/lib/rails-app')
-    @builder.expects(:create_dir_if_needed).with('/a/path/to/rails-app/working/dir/debian/tmp/var/log/rails-app/apache2')
+    it "should be able to create the needed install dirs" do
+      @builder.expects(:create_dir_if_needed).with('/a/path/to/rails-app/working/dir/debian/tmp/etc/init.d')
+      @builder.expects(:create_dir_if_needed).with('/a/path/to/rails-app/working/dir/debian/tmp/etc/apache2/sites-available')
+      @builder.expects(:create_dir_if_needed).with('/a/path/to/rails-app/working/dir/debian/tmp/etc/logrotate.d')
+      @builder.expects(:create_dir_if_needed).with('/a/path/to/rails-app/working/dir/debian/tmp/var/lib/rails-app')
+      @builder.expects(:create_dir_if_needed).with('/a/path/to/rails-app/working/dir/debian/tmp/var/log/rails-app/apache2')
     
-    @builder.create_install_dirs
-  end
+      @builder.create_install_dirs
+    end
   
-  it "should be able to generate a config file from @data, an erb template and a destination path" do
-    File.expects(:read).with('template_path').returns('template')
+    it "should be able to generate a config file from @data, an erb template and a destination path" do
+      File.expects(:read).with('template_path').returns('template')
     
-    @builder.expects(:render_template).with('template').returns('conf file')
+      @builder.expects(:render_template).with('template').returns('conf file')
     
-    mock_file = mock('File')
-    mock_file.expects(:write).with('conf file')
-    File.expects(:open).with('target_path', 'w').yields(mock_file)
+      mock_file = mock('File')
+      mock_file.expects(:write).with('conf file')
+      File.expects(:open).with('target_path', 'w').yields(mock_file)
     
-    @builder.generate_conf_file('template_path', 'target_path')
-  end
+      @builder.generate_conf_file('template_path', 'target_path')
+    end
   
-  it "should generate all the needed config files" do
-    @builder.expects(:generate_conf_file).with('/a/path/to/rails-app/working/dir/config/apache.conf.erb',
-                                               '/a/path/to/rails-app/working/dir/debian/tmp/etc/apache2/sites-available/rails-app')
+    it "should generate all the needed config files" do
+      @builder.expects(:generate_conf_file).with('/a/path/to/rails-app/working/dir/config/apache.conf.erb',
+                                                 '/a/path/to/rails-app/working/dir/debian/tmp/etc/apache2/sites-available/rails-app')
                                                
-    @builder.expects(:generate_conf_file).with('/a/path/to/rails-app/working/dir/config/logrotate.conf.erb',
-                                               '/a/path/to/rails-app/working/dir/debian/tmp/etc/logrotate.d/rails-app')
+      @builder.expects(:generate_conf_file).with('/a/path/to/rails-app/working/dir/config/logrotate.conf.erb',
+                                                 '/a/path/to/rails-app/working/dir/debian/tmp/etc/logrotate.d/rails-app')
                                                
-    @builder.expects(:generate_conf_file).with('/a/path/to/rails-app/working/dir/config/mongrel_cluster_init.erb',
-                                               '/a/path/to/rails-app/working/dir/debian/tmp/etc/init.d/rails-app')
+      @builder.expects(:generate_conf_file).with('/a/path/to/rails-app/working/dir/config/mongrel_cluster_init.erb',
+                                                 '/a/path/to/rails-app/working/dir/debian/tmp/etc/init.d/rails-app')
                                            
-    @builder.generate_conf_files
-  end
+      @builder.generate_conf_files
+    end
   
-  it "should be able to read the public ssh keys in deployers_ssh_keys" do
-    @data.stubs(:deployers_ssh_keys_dir).returns('/path/to/keys')
-    Dir.stubs(:entries).with('/path/to/keys').returns(['key1', 'key2'])
-    File.stubs(:file?).returns(true)
-    File.expects(:read).with('/path/to/keys/key1').returns('key1')
-    File.expects(:read).with('/path/to/keys/key2').returns('key2')
+    it "should be able to read the public ssh keys in deployers_ssh_keys" do
+      @data.stubs(:deployers_ssh_keys_dir).returns('/path/to/keys')
+      Dir.stubs(:entries).with('/path/to/keys').returns(['key1', 'key2'])
+      File.stubs(:file?).returns(true)
+      File.expects(:read).with('/path/to/keys/key1').returns('key1')
+      File.expects(:read).with('/path/to/keys/key2').returns('key2')
     
-    @builder.read_deployers_ssh_keys.should == ['key1', 'key2']
-  end
+      @builder.read_deployers_ssh_keys.should == ['key1', 'key2']
+    end
   
-  it "should be able to read the public ssh keys in deployers_ssh_keys, ignoring any directories there" do
-    @data.stubs(:deployers_ssh_keys_dir).returns('/path/to/keys')
-    Dir.stubs(:entries).with('/path/to/keys').returns(['is_a_dir', 'key1', 'key2'])
-    File.stubs(:file?).returns(true)
-    File.expects(:file?).with('/path/to/keys/is_a_dir').returns(false)
-    File.expects(:read).with('/path/to/keys/key1').returns('key1')
-    File.expects(:read).with('/path/to/keys/key2').returns('key2')
+    it "should be able to read the public ssh keys in deployers_ssh_keys, ignoring any directories there" do
+      @data.stubs(:deployers_ssh_keys_dir).returns('/path/to/keys')
+      Dir.stubs(:entries).with('/path/to/keys').returns(['is_a_dir', 'key1', 'key2'])
+      File.stubs(:file?).returns(true)
+      File.expects(:file?).with('/path/to/keys/is_a_dir').returns(false)
+      File.expects(:read).with('/path/to/keys/key1').returns('key1')
+      File.expects(:read).with('/path/to/keys/key2').returns('key2')
     
-    @builder.read_deployers_ssh_keys.should == ['key1', 'key2']
-  end
+      @builder.read_deployers_ssh_keys.should == ['key1', 'key2']
+    end
   
-  it "should be able to write out an authorized_keys file from a list of keys" do
-    mock_file = mock('File')
-    mock_file.expects(:write).with("key1\nkey2")
-    File.expects(:open).with('/a/path/to/rails-app/working/dir/debian/tmp/var/lib/rails-app/.ssh/authorized_keys', 'w').
-      yields(mock_file)
-    @builder.expects(:sh).with('chmod 600 "/a/path/to/rails-app/working/dir/debian/tmp/var/lib/rails-app/.ssh/authorized_keys"')
+    it "should be able to write out an authorized_keys file from a list of keys" do
+      mock_file = mock('File')
+      mock_file.expects(:write).with("key1\nkey2")
+      File.expects(:open).with('/a/path/to/rails-app/working/dir/debian/tmp/var/lib/rails-app/.ssh/authorized_keys', 'w').
+        yields(mock_file)
+      @builder.expects(:sh).with('chmod 600 "/a/path/to/rails-app/working/dir/debian/tmp/var/lib/rails-app/.ssh/authorized_keys"')
     
-    @builder.write_authorized_keys(['key1', 'key2'])
-  end
+      @builder.write_authorized_keys(['key1', 'key2'])
+    end
   
-  it "should be able to generate the authorized_keys file from the public keys in deployers_ssh_keys" do
-    @builder.expects(:create_dir_if_needed).with('/a/path/to/rails-app/working/dir/debian/tmp/var/lib/rails-app/.ssh')
-    @builder.expects(:sh).with('chmod 700 "/a/path/to/rails-app/working/dir/debian/tmp/var/lib/rails-app/.ssh"')
+    it "should be able to generate the authorized_keys file from the public keys in deployers_ssh_keys" do
+      @builder.expects(:create_dir_if_needed).with('/a/path/to/rails-app/working/dir/debian/tmp/var/lib/rails-app/.ssh')
+      @builder.expects(:sh).with('chmod 700 "/a/path/to/rails-app/working/dir/debian/tmp/var/lib/rails-app/.ssh"')
     
-    @builder.expects(:read_deployers_ssh_keys).returns(['key1', 'key2'])
-    @builder.expects(:write_authorized_keys).with(['key1', 'key2'])
+      @builder.expects(:read_deployers_ssh_keys).returns(['key1', 'key2'])
+      @builder.expects(:write_authorized_keys).with(['key1', 'key2'])
     
-    @builder.generate_authorized_keys
-  end
+      @builder.generate_authorized_keys
+    end
   
-  it "should be able to perform all the needed steps to put install the package's files " do
-    @builder.expects(:generate_conf_files)
-    @builder.expects(:sh).with('chown -R root:root "/a/path/to/rails-app/working/dir/debian/tmp"')
-    @builder.expects(:sh).with('chmod 755 "/a/path/to/rails-app/working/dir/debian/tmp/etc/init.d/rails-app"')
+    it "should be able to perform all the needed steps to put install the package's files " do
+      @builder.expects(:generate_conf_files)
+      @builder.expects(:sh).with('chown -R root:root "/a/path/to/rails-app/working/dir/debian/tmp"')
+      @builder.expects(:sh).with('chmod 755 "/a/path/to/rails-app/working/dir/debian/tmp/etc/init.d/rails-app"')
     
-    @builder.expects(:generate_authorized_keys)
+      @builder.expects(:generate_authorized_keys)
     
-    @builder.install_package_files
+      @builder.install_package_files
+    end
   end
 end