dpkg-tools 0.3.3

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

@@ -0,0 +1,68 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe DpkgTools::Package::Gem do
+  before(:each) do
+    @setup = mock('mock DpkgTools::Package::Gem::Setup')
+  end
+  
+  it "should be able to create package structure from a path to a gem file" do
+    DpkgTools::Package::Gem::Setup.expects(:from_path).with('path/to/stub.gem').returns(@setup)
+    @setup.expects(:create_structure)
+    
+    DpkgTools::Package::Gem.setup_from_path('path/to/stub.gem', {:ignore_dependencies => true})
+  end
+  
+  it "should be able to create package structure from a path to a gem file, ignoring dependency-related options" do
+    DpkgTools::Package::Gem::Setup.expects(:from_path).with('path/to/stub.gem').returns(@setup)
+    @setup.expects(:create_structure)
+    
+    DpkgTools::Package::Gem.setup_from_path('path/to/stub.gem', {:ignore_dependencies => false})
+  end
+  
+  it "should be able to create package structure from the name of a gem" do
+    DpkgTools::Package::Gem::Setup.expects(:from_name).with('stub_gem').returns(@setup)
+    @setup.expects(:create_structure)
+    
+    DpkgTools::Package::Gem.setup_from_name('stub_gem', {:ignore_dependencies => true})
+  end
+  
+  it "should be able to create package structure and fetch dependencies" do
+    DpkgTools::Package::Gem::Setup.expects(:from_name).with('stub_gem').returns(@setup)
+    mock_dependency_setup = mock('mock DpkgTools::Package::Gem::Setup for dependency')
+    mock_dependency_setup.expects(:create_structure)
+    
+    @setup.expects(:fetch_dependencies).returns([mock_dependency_setup])
+    @setup.expects(:create_structure)
+    
+    DpkgTools::Package::Gem.setup_from_name('stub_gem', {})
+  end
+end
+
+describe DpkgTools::Package::Gem, ".config_cache method" do
+  before(:each) do
+    DpkgTools::Package::Gem.instance_variable_set(:@config_cache, {})
+  end
+  
+  it "should create and return a DpkgTools::Package::Config instance corresponding to the given full name key" do
+    DpkgTools::Package::Config.expects(:new).with('gem_name', '1.0.8', {:suffix => 'rubygem'}).returns(:config)
+    DpkgTools::Package::Gem.config_cache(['gem_name', '1.0.8']).should == :config
+  end
+  
+  it "should only create and return a single DpkgTools::Package::Config instance" do
+    DpkgTools::Package::Gem.config_cache(['gem_name', '1.0.8']).should === DpkgTools::Package::Gem.config_cache(['gem_name', '1.0.8'])
+  end
+  
+  it "should yield the Config instance if passed a block" do
+    result = nil
+    DpkgTools::Package::Gem.config_cache(['gem_name', '1.0.8']) {|cfg| result = cfg}
+    result.should == DpkgTools::Package::Gem.config_cache(['gem_name', '1.0.8'])
+  end
+end
+
+describe DpkgTools::Package::Gem, ".create_builder" do
+  it "should instantiate a Package::Gem::Data and a Package::Gem::Builder and make 'em work" do
+    DpkgTools::Package::Gem::Builder.expects(:from_file_path).with('a/path/to/stub_gem-1.1.0/stub_gem-1.1.0.gem').returns(:builder)
+    
+    DpkgTools::Package::Gem.create_builder('a/path/to/stub_gem-1.1.0/stub_gem-1.1.0.gem').should == :builder
+  end
+end

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

@@ -0,0 +1,113 @@
+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
+  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')
+    
+    @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 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
+  
+  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')
+    
+    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
+  
+  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/mongrel_cluster_init.erb',
+                                               '/a/path/to/rails-app/working/dir/debian/tmp/etc/init.d/rails-app')
+                                           
+    @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')
+    
+    @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')
+    
+    @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"')
+    
+    @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"')
+    
+    @builder.expects(:read_deployers_ssh_keys).returns(['key1', 'key2'])
+    @builder.expects(:write_authorized_keys).with(['key1', 'key2'])
+    
+    @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"')
+    
+    @builder.expects(:generate_authorized_keys)
+    
+    @builder.install_package_files
+  end
+end

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

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe DpkgTools::Package::Rails::Cap, "variables for use in Cap 2 recipes" do
+  it "should be able to tell if the current dir has the app's config dir in it" do
+    Dir.stubs(:entries).with('path').returns(['.', '..', 'app', 'config'])
+    DpkgTools::Package::Rails::Cap.dir_contains_config?('path').should be_true
+  end
+  
+  it "should be able to work out where the root of the app is" do
+    Dir.stubs(:pwd).returns('/a/path/to/rails-app')
+    DpkgTools::Package::Rails::Cap.stubs(:dir_contains_config?).returns(true)
+    DpkgTools::Package::Rails::Cap.located_app_root.should == '/a/path/to/rails-app'
+  end
+  
+  it "should be able to hunt back up the path if necessary" do
+    Dir.stubs(:pwd).returns('/a/path/to/rails-app/app/models')
+    DpkgTools::Package::Rails::Cap.stubs(:dir_contains_config?).with('/a/path/to/rails-app/app/models').returns(false)
+    DpkgTools::Package::Rails::Cap.stubs(:dir_contains_config?).with('/a/path/to/rails-app/app').returns(false)
+    DpkgTools::Package::Rails::Cap.stubs(:dir_contains_config?).with('/a/path/to/rails-app').returns(true)
+    
+    DpkgTools::Package::Rails::Cap.located_app_root.should == '/a/path/to/rails-app'
+  end
+  
+  it "should raise an error if it has to hunt back to / for the app's root" do
+    Dir.stubs(:pwd).returns('/a/path/to/rails-app')
+    DpkgTools::Package::Rails::Cap.stubs(:dir_contains_config?).returns(false)
+    
+    lambda { DpkgTools::Package::Rails::Cap.located_app_root }.should raise_error(DpkgTools::Package::Rails::CannotLocateAppDir)
+  end
+  
+  it "should be able to return a DpkgTools::Package::Rails::Data instance" do
+    DpkgTools::Package::Rails::Cap.stubs(:located_app_root).returns('/a/path/to/rails-app')
+    DpkgTools::Package::Rails::Data.expects(:new).with('/a/path/to/rails-app').returns(:data)
+    
+    DpkgTools::Package::Rails.cap.should == :data
+  end
+end

data/spec/dpkg-tools/package/rails/control_files/changelog_spec.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/../../../../spec_helper'
+
+describe DpkgTools::Package::Rails::ControlFiles::Changelog, "#changelog" do
+  before(:each) do
+    config = DpkgTools::Package::Config.new('rails-app', '1.0.8')
+    stub_data = stub('DpkgTools::Package::Rails::Data', :full_name => 'rails-app-1.0.8', :debian_revision => '1')
+    @metadata = DpkgTools::Package::Rails::ControlFiles::Changelog.new(stub_data, config)
+  end
+  
+  it "should be able to generate the current time formatted as per RFC 822" do
+    mock_time = mock('Time')
+    mock_time.expects(:rfc822).returns('rfc_time')
+    Time.expects(:now).returns(mock_time)
+    
+    @metadata.change_time.should == 'rfc_time'
+  end
+  
+  it "should be able to generate a changelog" do
+    @metadata.expects(:change_time).returns('RFC 822 change time')
+    
+    @metadata.changelog.should == "rails-app (1.0.8-1) cp-gutsy; urgency=low\n"\
+    "  * Packaged up rails-app-1.0.8\n"\
+    " -- Matt Patterson <matt@reprocessed.org>  RFC 822 change time\n"
+  end
+end

data/spec/dpkg-tools/package/rails/control_files/rakefile_spec.rb

@@ -0,0 +1,24 @@
+require File.dirname(__FILE__) + '/../../../../spec_helper'
+
+describe DpkgTools::Package::Rails::ControlFiles::Rakefile do
+  before(:each) do
+    config = DpkgTools::Package::Config.new("rails-app", "1.0.8", :base_path => '/a/path/to/app')
+    stub_data = stub("DpkgTools::Package::Rails::Data", :full_name => "rails-app-1.0.8")
+    @control_file = DpkgTools::Package::Rails::ControlFiles::Rakefile.new(stub_data, config)
+  end
+  
+  it "should be able to generate the contents of the Rakefile" do
+    @control_file.rakefile.should == "require 'rubygems'\n" \
+    "begin\n" \
+    "  require 'dpkg-tools'\n" \
+    "rescue LoadError\n" \
+    "  # dpkg-tools not available (because we don't really need it on deployment targets)\n" \
+    "end\n" \
+    "\n" \
+    "if defined?(DpkgTools::Package::Rails)\n" \
+    "  DpkgTools::Package::Rails::BuildTasks.new do |t|\n" \
+    "    t.base_path = Rake.original_dir\n" \
+    "  end\n" \
+    "end\n"
+  end
+end

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

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe DpkgTools::Package::Rails::ControlFiles do
+  it "should provide access to the list of control file classes" do
+    DpkgTools::Package::Rails::ControlFiles.classes.
+      should == [DpkgTools::Package::Rails::ControlFiles::Changelog,
+                 DpkgTools::Package::ControlFiles::Control,
+                 DpkgTools::Package::ControlFiles::Copyright,
+                 DpkgTools::Package::Rails::ControlFiles::Rakefile,
+                 DpkgTools::Package::ControlFiles::Rules]
+  end
+end

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

@@ -0,0 +1,178 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe DpkgTools::Package::Rails::Data, ".load_package_data" do
+  it "should be able to read in the config/*.yml file" do
+    File.expects(:exist?).with('base_path/config/deb.yml').returns(true)
+    YAML.expects(:load_file).with('base_path/config/deb.yml').returns({"name" => 'rails-app'})
+    DpkgTools::Package::Rails::Data.load_package_data('base_path', 'deb.yml').should == {"name" => 'rails-app'}
+  end
+end
+
+describe DpkgTools::Package::Rails::Data, "base dependencies" do
+  it "should return a sensible list of base gem dependencies" do
+    DpkgTools::Package::Rails::Data.base_gem_deps.
+      should == [{:name => 'rails-rubygem', :requirements => ['>= 1.2.5-1']},
+                 {:name => 'rake-rubygem', :requirements => ['>= 0.7.3-1']},
+                 {:name => 'mysql-rubygem', :requirements => ['>= 2.7-1']},
+                 {:name => 'mongrel-cluster-rubygem', :requirements => ['>= 1.0.1-1']}]
+  end
+  
+  it "should return a sensible list of base package dependencies" do
+    DpkgTools::Package::Rails::Data.base_deps.
+      should == [{:name => 'mysql-client'}, {:name => 'mysql-server'}, {:name => 'apache2'}, 
+                 {:name => 'ruby', :requirements => ['>= 1.8.2']}]    
+  end
+end
+
+describe DpkgTools::Package::Rails::Data, ".new" do
+  it "should raise an error without any arguments" do
+    lambda { DpkgTools::Package::Gem::Data.new }.should raise_error
+  end
+  
+  it "should take the rails app base path, then read in the config/deb.yml" do
+    DpkgTools::Package::Rails::Data.expects(:load_package_data).with('base_path', 'deb.yml').returns({'name' => 'rails-app', 'version' => '1.0.8'})
+    DpkgTools::Package::Rails::Data.expects(:load_package_data).with('base_path', 'database.yml').returns({'development' => {'database' => 'db_name'}})
+    DpkgTools::Package::Rails::Data.expects(:process_dependencies).with({'name' => 'rails-app', 'version' => '1.0.8'}).returns(:deps)
+    DpkgTools::Package::Rails::Data.new('base_path').should be_an_instance_of(DpkgTools::Package::Rails::Data)
+  end
+end
+
+describe DpkgTools::Package::Rails::Data, "instances" do
+  before(:each) do
+    @mongrel_cluster_config_data = {'port' => '8000', 'servers' => 3}
+    package_data = {'name' => 'rails-app', 'version' => '1.0.8', 'license' => '(c) Matt 4evah', 
+                    'summary' => "Matt's great Rails app", 'server_name' => 'test.host', 
+                    'server_aliases' => ['www.test.host'],
+                    'mongrel_cluster' => @mongrel_cluster_config_data}
+    DpkgTools::Package::Rails::Data.stubs(:load_package_data).with('base_path', 'deb.yml').
+      returns(package_data)
+    @database_configurations = YAML.load_file(File.dirname(__FILE__) + '/../../../fixtures/database.yml')
+    DpkgTools::Package::Rails::Data.stubs(:load_package_data).with('base_path', 'database.yml').returns(@database_configurations)
+    DpkgTools::Package::Rails::Data.expects(:process_dependencies).with(package_data).returns(:deps)
+    @data = DpkgTools::Package::Rails::Data.new('base_path')
+  end
+  
+  it "should provide access to its name" do
+    @data.name.should == 'rails-app'
+  end
+  
+  it "should convert the Gem::Version object to a string" do
+    @data.version.should == '1.0.8'
+  end
+  
+  it "should provide access to the changelog-derived debian_revision" do
+    @data.debian_revision.should == "1"
+  end
+  
+  it "should provide access to the debian architecture name" do
+    @data.debian_arch.should == "all"
+  end
+  
+  it "should provide access to its license" do
+    @data.license.should == "(c) Matt 4evah"
+  end
+  
+  it "should provide access to its install-time deps" do
+    @data.dependencies.should == :deps
+  end
+  
+  it "should provide access to its build-time deps" do
+    @data.build_dependencies.should == :deps
+  end
+  
+  it "should provide access to its summary" do
+    @data.summary.should == "Matt's great Rails app"
+  end
+  
+  it "should provide access to its 'full_name' equivalent" do
+    @data.full_name.should == 'rails-app-1.0.8'
+  end
+  
+  it "should provide access to its base_path" do
+    @data.base_path.should == 'base_path'
+  end
+  
+  it "should provide the rakefile_location information so the rakefile can be generated in the right place" do
+    @data.rakefile_location.should == [:base_path, 'lib/tasks/dpkg-tools.rake']
+  end
+  
+  it "should provide access to its mongrel starting port" do
+    @data.mongrel_cluster_start_port.should == '8000'
+  end
+  
+  it "should provide access to the number of mongrels specified" do
+    @data.number_of_mongrels.should == 3
+  end
+  
+  it "should provide access to an array of the port numbers to be used by the mongrels" do
+    @data.mongrel_ports.should == ['8000', '8001', '8002']
+  end
+  
+  it "should provide access to the path of the resources dir in the gem" do
+    DpkgTools::Package::Rails::Data.resources_path.should == File.expand_path(File.dirname(__FILE__) + '/../../../../resources/rails')
+  end
+  
+  it "should provide access to the target installation path for the app (i.e. /var/lib/blah)" do
+    @data.app_install_path.should == '/var/lib/rails-app'
+  end
+  
+  it "should provide access to the server's main DNS name" do
+    @data.server_name.should == 'test.host'
+  end
+  
+  it "should provide access to any DNS aliases the server will have" do
+    @data.server_aliases.should == ['www.test.host']
+  end
+  
+  it "should provide access to the apps' databases" do
+    @data.database_configurations.should == @database_configurations
+  end
+  
+  it "should provide the system user name for the app" do
+    @data.username.should == 'rails-app'
+  end
+  
+  it "should provide the path to the cluster's PIDfile dir" do
+    @data.pidfile_dir_path.should == '/var/run/rails-app'
+  end
+  
+  it "should provide the path to the logfile dirs" do
+    @data.logfile_path.should == '/var/log/rails-app'
+  end
+  
+  it "should provide the path to the cluster's config root in /etc" do
+    @data.conf_dir_path.should == '/var/lib/rails-app/current/config'
+  end
+  
+  it "should provide the capistrano application name" do
+    @data.application.should == @data.name
+  end
+  
+  it "should provide the name of the user to ssh into servers as" do
+    @data.user.should == @data.name
+  end
+  
+  it "should provide the path to the capistrano deploy_to location" do
+    @data.deploy_to.should == @data.app_install_path
+  end
+  
+  it "should provide the path to the deployer's ssh keys dir in the package dir" do
+    @data.deployers_ssh_keys_dir.should == 'base_path/config/deployers_ssh_keys'
+  end
+  
+  it "should provide access to the init script's path" do
+    @data.init_script_path.should == '/etc/init.d/rails-app'
+  end
+  
+  it "should provide access to the app user's .ssh path" do
+    @data.dot_ssh_path.should == '/var/lib/rails-app/.ssh'
+  end
+  
+  it "should provide access to the app user's ssh authorized_keys file" do
+    @data.authorized_keys_path.should == '/var/lib/rails-app/.ssh/authorized_keys'
+  end
+  
+  it "should provide access to the raw hash for mongrel_cluster data" do
+    @data.mongrel_cluster_config_hash.should == @mongrel_cluster_config_data
+  end
+end