dpkg-tools 0.3.3

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

@@ -0,0 +1,78 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'rake'
+
+describe DpkgTools::Package::Rails::BuildTasks, "task creation" do
+  it "check_setup should be fine if base_path is defined" do
+    DpkgTools::Package::Rails::BuildTasks.any_instance.stubs(:define_tasks)
+    DpkgTools::Package::Rails::BuildTasks.any_instance.stubs(:define_base_tasks)
+    
+    result = DpkgTools::Package::Rails::BuildTasks.new do |t| 
+      t.base_path = 'path'
+    end
+    result.base_path.should == 'path'
+  end
+  
+  it "should raise an error if base_path hasn't been defined" do
+    DpkgTools::Package::Rails::BuildTasks.any_instance.stubs(:define_tasks)
+    DpkgTools::Package::Rails::BuildTasks.any_instance.stubs(:define_base_tasks)
+    
+    lambda { DpkgTools::Package::Rails::BuildTasks.new }.should raise_error(ArgumentError)
+  end
+  
+  it "should be able to return a properly instantiated Builder from create_builder" do
+    build_tasks = DpkgTools::Package::Rails::BuildTasks.new do |t| 
+      t.base_path = 'path'
+    end
+    
+    DpkgTools::Package::Rails.expects(:create_builder).with('path').returns(:builder)
+    
+    build_tasks.create_builder.should == :builder
+  end
+  
+  it "should be able to return a properly instantiated Setup from create_setup" do
+    build_tasks = DpkgTools::Package::Rails::BuildTasks.new do |t| 
+      t.base_path = 'path'
+    end
+    
+    DpkgTools::Package::Rails.expects(:create_setup).with('path').returns(:setup)
+    
+    build_tasks.create_setup.should == :setup
+  end
+end
+
+describe DpkgTools::Package::Rails::BuildTasks, "rake tasks" do
+  before(:each) do
+    @rake = Rake::Application.new
+    Rake.application = @rake
+    
+    @build_tasks = DpkgTools::Package::Rails::BuildTasks.new do |t| 
+      t.base_path = "base_path"
+    end
+  end
+  
+  after(:each) do
+    Rake.application = nil
+  end
+  
+  it "should properly call the DpkgTools::Package::Rails.create_builder from the task 'binary-arch'" do
+    mock_builder = mock('DpkgTools::Package::Rails::Builder')
+    mock_builder.expects(:binary_package)
+    @build_tasks.expects(:create_builder).returns(mock_builder)
+    @rake["binary-arch"].invoke
+  end
+  
+  it "should properly call the DpkgTools::Package::Rails.create_builder from the task 'binary-indep'" do
+    mock_builder = mock('DpkgTools::Package::Rails::Builder')
+    mock_builder.expects(:binary_package)
+    @build_tasks.expects(:create_builder).returns(mock_builder)
+    @rake["binary-indep"].invoke
+  end
+  
+  it "should be able to correctly generate the mongrel_cluster YAML config file" do
+    mock_setup = mock('DpkgTools::Package::Rails::Setup')
+    mock_setup.expects(:generate_mongrel_cluster_config)
+    @build_tasks.expects(:create_setup).returns(mock_setup)
+    @rake["dpkg:mongrel_cluster"].invoke
+  end
+end

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

@@ -0,0 +1,152 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe DpkgTools::Package::Rails::Setup, ".from_path" do
+  it "should return the correct class from .data_class" do
+    DpkgTools::Package::Rails::Setup.data_class.should == DpkgTools::Package::Rails::Data
+  end
+  
+  it "should create a DpkgTools::Package::Rails::Data instance, and feed it to .new" do
+    DpkgTools::Package::Rails::Setup.stubs(:needs_bootstrapping?).returns(false)
+    DpkgTools::Package::Rails::Data.expects(:new).with('base_path').returns(:data)
+    DpkgTools::Package::Rails::Setup.expects(:new).with(:data, 'base_path').returns(:instance)
+    
+    DpkgTools::Package::Rails::Setup.from_path('base_path').should == :instance
+  end
+end
+
+describe DpkgTools::Package::Rails::Setup, "bootstrapping" do
+  before(:each) do
+    DpkgTools::Package::Rails::Data.stubs(:resources_path).returns('/a/path/to/resources')
+  end
+  
+  it "should be able to construct the target file path of a file for bootstrapping" do
+    DpkgTools::Package::Rails::Setup.bootstrap_file_path('base_path', 'deb.yml').
+      should == 'base_path/config/deb.yml'
+  end
+  
+  it "should be able to report which files are needed for bootstrapping" do
+    DpkgTools::Package::Rails::Setup.bootstrap_files.should == ['deb.yml']
+  end
+end
+
+describe DpkgTools::Package::Rails::Setup, ".new" do
+  before(:each) do
+    @data = stub('stub DpkgTools::Package::Rails::Data', :name => 'name', :version => '1', :base_path => 'base_path')
+  end
+  
+  it "should raise an error without any arguments" do
+    lambda { DpkgTools::Package::Rails::Setup.new }.should raise_error
+  end
+  
+  it "should require one argument" do
+    DpkgTools::Package::Rails::Setup.new(@data)
+  end
+  
+  it "should result in @config being set to a DpkgTools::Package::Config instance" do
+    setup = DpkgTools::Package::Rails::Setup.new(@data)
+    setup.config.should be_an_instance_of(DpkgTools::Package::Config)
+  end
+end
+
+describe DpkgTools::Package::Rails::Setup do
+  before(:each) do
+    @data = stub('stub DpkgTools::Package::Rails::Data', :name => 'name', :version => '1', :base_path => 'base_path', 
+                                                        :resources_path => '/a/path/to/resources',
+                                                        :app_install_path => '/var/lib/name',
+                                                        :pidfile_dir_path => '/var/run/name',
+                                                        :mongrel_cluster_config_hash => {'port' => "8000",
+                                                          'environment' => 'production',
+                                                          'address' => '127.0.0.1',
+                                                          'servers' => 3})
+    @data.stubs(:deployers_ssh_keys_dir).returns('deployers_ssh_keys')
+    @config = DpkgTools::Package::Config.new('name', '1', :base_path => 'base_path')
+  end
+  
+  it "should be able to provide a list of the resource files to be copied across during setup" do
+    DpkgTools::Package::Rails::Setup.resource_file_names.
+      should == ['apache.conf.erb', 'logrotate.conf.erb', 'mongrel_cluster_init.erb', 'deploy.rb']
+  end
+  
+  it ".prepare_package should copy the conf templates and extra structures across" do
+    DpkgTools::Package::Rails::Setup.stubs(:resource_file_names).returns(['apache.conf.erb'])
+    DpkgTools::Package::Rails::Data.stubs(:resources_path).returns('/a/path/to/resources')
+    data = stub('stub DpkgTools::Package::Rails::Data', :name => 'name', :version => '1', :base_path => 'base_path', 
+                                                        :resources_path => '/a/path/to/resources')
+    data.stubs(:deployers_ssh_keys_dir).returns('deployers_ssh_keys')
+    config = DpkgTools::Package::Config.new('name', '1', :base_path => 'base_path')
+    DpkgTools::Package::Rails::Setup.expects(:bootstrap_file).with('base_path', 'apache.conf.erb')
+    
+    DpkgTools::Package::Rails::Setup.expects(:create_dir_if_needed).with('deployers_ssh_keys')
+    
+    DpkgTools::Package::Rails::Setup.expects(:sh).with('capify "base_path"')
+    DpkgTools::Package::Rails::Setup.expects(:generate_mongrel_cluster_config).with(@data, @config)
+    
+    DpkgTools::Package::Rails::Setup.prepare_package(@data, @config)
+  end
+  
+  it "should be able to back up and reset the resource files created by .prepare_package" do
+    DpkgTools::Package::Rails::Setup.stubs(:resource_file_names).returns(['apache.conf.erb'])
+    DpkgTools::Package::Rails::Setup.expects(:bootstrap_file).with('base_path', 'apache.conf.erb', :backup => true)
+    
+    DpkgTools::Package::Rails::Setup.reset_package_resource_files(@data, @config)
+  end
+  
+  it "should be able to generate the complete config/mongrel_cluster.yml hash" do
+    DpkgTools::Package::Rails::Setup.generate_mongrel_cluster_config_hash(@data, @config).
+      should == {'port' => "8000",
+                 'environment' => 'production',
+                 'address' => '127.0.0.1',
+                 'servers' => 3,
+                 'pid_file' => '/var/run/name/mongrel.pid',
+                 'cwd' => '/var/lib/name/current',
+                 'log_file' => 'log/mongrel.log',
+                 'user' => 'name',
+                 'group' => 'name'}
+  end
+  
+  it "should be able to write the config/mongrel_cluster.yml file" do
+    conf_data = {'port' => '8000'}
+    conf_data.expects(:to_yaml).returns("---\nport: blah")
+    DpkgTools::Package::Rails::Setup.expects(:generate_mongrel_cluster_config_hash).with(@data, @config).returns(conf_data)
+    mock_file = mock('File')
+    mock_file.expects(:write).with("# Auto-generated by dpkg-tools, don't edit!\n# You can edit config/deb.yml and then regenerate this file\n# with rake dpkg:mongrel_cluster.\n\nport: blah")
+    File.expects(:open).with('base_path/config/mongrel_cluster.yml', 'w').yields(mock_file)
+    
+    DpkgTools::Package::Rails::Setup.generate_mongrel_cluster_config(@data, @config)
+  end
+end
+
+describe DpkgTools::Package::Rails::Setup, "instances" do
+  before(:each) do
+    @data = stub("stub DpkgTools::Package::Rails::Data", :name => 'rails-app-name', :version => '1.0.8', 
+                 :full_name => 'rails-app-name-1.0.8', :base_path => 'base_path')
+    @setup = DpkgTools::Package::Rails::Setup.new(@data)
+  end
+  
+  it "should provide access to the correct options for making a new DpkgTools::Package::Config" do
+    @setup.config_options.should == {:base_path => 'base_path'}
+  end
+  
+  it "should provide access to its Package::Rails::Data" do
+    @setup.data.should == @data
+  end
+  
+  it "should be able to return the correct list of classes to build control files with" do
+    @setup.control_file_classes.should == DpkgTools::Package::Rails::ControlFiles.classes
+  end
+  
+  it "should properly invoke .prepare_package from #prepare_package" do
+    DpkgTools::Package::Rails::Setup.expects(:prepare_package).with(@setup.data, @setup.config)
+    @setup.prepare_package
+  end
+  
+  it "should properly invoke .prepare_package from #prepare_package" do
+    DpkgTools::Package::Rails::Setup.expects(:generate_mongrel_cluster_config).with(@setup.data, @setup.config)
+    @setup.generate_mongrel_cluster_config
+  end
+  
+  it "should properly invoke .reset_package_resource_files from #reset_package_resource_files" do
+    DpkgTools::Package::Rails::Setup.expects(:reset_package_resource_files).with(@setup.data, @setup.config)
+    @setup.reset_package_resource_files
+  end
+end

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

@@ -0,0 +1,27 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe DpkgTools::Package::Rails, ".create_builder" do
+  it "should instantiate a Package::Rails::Data and a Package::Rails::Builder and make 'em work" do
+    DpkgTools::Package::Rails::Builder.expects(:from_path).with('/a/path/to/rails-app').returns(:builder)
+    
+    DpkgTools::Package::Rails.create_builder('/a/path/to/rails-app').should == :builder
+  end
+end
+
+describe DpkgTools::Package::Rails, ".setup_from_path" do
+  it "should be able to create package structure from a path to a gem file" do
+    mock_setup = mock('mock DpkgTools::Package::Rails::Setup')
+    DpkgTools::Package::Rails::Setup.expects(:from_path).with('/path/to/rails-app').returns(mock_setup)
+    mock_setup.expects(:create_structure)
+    
+    DpkgTools::Package::Rails.setup_from_path('/path/to/rails-app')
+  end
+end
+
+describe DpkgTools::Package::Rails, ".create_setup" do
+  it "should be able to create a Setup instance" do
+    DpkgTools::Package::Rails::Setup.expects(:from_path).with('/path/to/rails-app').returns(:setup)
+    
+    DpkgTools::Package::Rails.create_setup('/path/to/rails-app').should == :setup
+  end
+end

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

@@ -0,0 +1,87 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe DpkgTools::Package::BuildTasks, "task creation" do
+  it "should yield itself if a block is given to .new" do
+    DpkgTools::Package::BuildTasks.any_instance.stubs(:define_tasks)
+    
+    yielded_result = nil
+    result = DpkgTools::Package::BuildTasks.new do |t| 
+      yielded_result = t
+    end
+    result.should === yielded_result
+  end
+  
+  it "should call the necessary methods to set up the base and subclass Rake tasks on init" do
+    DpkgTools::Package::BuildTasks.any_instance.expects(:check_setup)
+    DpkgTools::Package::BuildTasks.any_instance.expects(:define_tasks)
+    DpkgTools::Package::BuildTasks.any_instance.expects(:define_base_tasks)
+                      
+    DpkgTools::Package::BuildTasks.new
+  end
+end
+
+describe DpkgTools::Package::BuildTasks, "instances" do
+  before(:each) do
+    @rake = Rake::Application.new
+    Rake.application = @rake
+    
+    @build_tasks = DpkgTools::Package::BuildTasks.new
+    @mock_builder = stub('DpkgTools::Package::Builder')
+    @build_tasks.stubs(:create_builder).returns(@mock_builder)
+    @mock_setup = stub('DpkgTools::Package::Setup')
+    @build_tasks.stubs(:create_setup).returns(@mock_setup)
+  end
+  
+  after(:each) do
+    Rake.application = nil
+  end
+  
+  it "should define the needed base tasks for debian/rules emulation" do
+    @build_tasks.stubs(:task).with(anything)
+    @build_tasks.expects(:task).with(:clean)
+    @build_tasks.expects(:task).with('build-arch')
+    @build_tasks.expects(:task).with('build-indep')
+    @build_tasks.expects(:task).with(:build)
+    @build_tasks.expects(:task).with("binary-arch")
+    @build_tasks.expects(:task).with("binary-indep")
+    @build_tasks.expects(:task).with(:binary)
+    
+    @build_tasks.define_base_tasks
+  end
+  
+  it "should invoke binary-arch from :binary when the builder says it's an arch package" do
+    @mock_builder.expects(:architecture_independent?).returns(false)
+    
+    @rake['binary-arch'].expects(:invoke)
+    @rake['binary'].invoke
+  end
+  
+  it "should invoke binary-indep from :binary when the builder says it's an arch-indep package" do
+    @mock_builder.expects(:architecture_independent?).returns(true)
+    
+    @rake['binary-indep'].expects(:invoke)
+    @rake['binary'].invoke
+  end
+  
+  it "should invoke build-arch from :build when the builder says it's an arch package" do
+    @mock_builder.expects(:architecture_independent?).returns(false)
+    
+    @rake['build-arch'].expects(:invoke)
+    @rake['build'].invoke
+  end
+  
+  it "should invoke build-indep from :build when the builder says it's an arch-indep package" do
+    @mock_builder.expects(:architecture_independent?).returns(true)
+    
+    @rake['build-indep'].expects(:invoke)
+    @rake['build'].invoke
+  end
+  
+  it "should call the correct reset methods on a setup instance from dpkg:setup:reset" do
+    @mock_setup.expects(:reset_maintainer_script_templates)
+    @mock_setup.expects(:reset_control_files)
+    @mock_setup.expects(:reset_package_resource_files)
+    
+    @rake['dpkg:setup:reset'].invoke
+  end
+end

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

@@ -0,0 +1,247 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe DpkgTools::Package::Setup do
+  describe "bootstrapping" do
+    it "should report that it does NOT need bootstrapping if deb.yml is present" do
+      DpkgTools::Package::Setup.expects(:bootstrap_file_path).with('base_path', 'deb.yml').returns('base_path/deb.yml')
+      DpkgTools::Package::Setup.expects(:bootstrap_files).returns('deb.yml')
+      File.expects(:file?).with('base_path/deb.yml').returns(true)
+
+      DpkgTools::Package::Setup.needs_bootstrapping?('base_path').should be_false
+    end
+    
+    it "should report that it does need bootstrapping if deb.yml is NOT present" do
+      DpkgTools::Package::Setup.expects(:bootstrap_file_path).with('base_path', 'deb.yml').returns('base_path/deb.yml')
+      DpkgTools::Package::Setup.expects(:bootstrap_files).returns('deb.yml')
+      File.expects(:file?).with('base_path/deb.yml').returns(false)
+
+      DpkgTools::Package::Setup.needs_bootstrapping?('base_path').should be_true
+    end
+    
+    it "should respond to bootstrap" do
+      DpkgTools::Package::Setup.should respond_to(:bootstrap)
+    end
+    
+    it "should provide a for-overriding bootstrap_files method" do
+      DpkgTools::Package::Setup.bootstrap_files.should == ['deb.yml']
+    end
+    
+    it "should provide a for-overriding bootstrap_file_path method" do
+      DpkgTools::Package::Setup.bootstrap_file_path('base_path', 'deb.yml').should == 'base_path/deb.yml'
+    end
+    
+    describe ".bootstrap_file support methods" do
+      it "should be able to report that a target file already exists" do
+        File.stubs(:file?).with('target/file/path').returns(true)
+        DpkgTools::Package::Setup.file_exists?('target/file/path').should be_true
+      end
+      
+      it "should be able to report that a target file does not already exist" do
+        File.stubs(:file?).with('target/file/path').returns(false)
+        DpkgTools::Package::Setup.file_exists?('target/file/path').should be_false
+      end
+      
+      it "should be able to move a target file out of the way by adding a .bak suffix" do
+        FileUtils.expects(:mv).with('target/file/path', 'target/file/path.bak')
+        DpkgTools::Package::Setup.move_original_aside('target/file/path')
+      end
+      
+      it "should be able to copy a bootstrap file across to a target file path" do
+        FileUtils.expects(:cp).with('source/file/path', 'target/file/path.bak')
+        DpkgTools::Package::Setup.copy_bootstrap_file_across('source/file/path', 'target/file/path.bak')
+      end
+    end
+    
+    describe ".bootstrap_file" do
+      before(:each) do
+        mock_data_class = mock('DpkgTools::Package::Data')
+        mock_data_class.stubs(:resources_path).returns('/a/path/to/resources')
+        DpkgTools::Package::Setup.stubs(:data_class).returns(mock_data_class)
+      end
+      
+      it "should be able to create a needed files" do
+        DpkgTools::Package::Setup.expects(:bootstrap_file_path).with('base_path', 'deb.yml').returns('bootstrap_file_path')
+        File.stubs(:file?).with('bootstrap_file_path').returns(false)
+        
+        FileUtils.expects(:cp).with('/a/path/to/resources/deb.yml', 'bootstrap_file_path')
+        
+        DpkgTools::Package::Setup.bootstrap_file('base_path', 'deb.yml')
+      end
+      
+      it "should not, by default, attempt to create a file that's already there..." do
+        DpkgTools::Package::Setup.expects(:bootstrap_file_path).with('base_path', 'deb.yml').returns('bootstrap_file_path')
+        File.stubs(:file?).with('bootstrap_file_path').returns(true)
+        
+        FileUtils.expects(:cp).never
+        
+        DpkgTools::Package::Setup.bootstrap_file('base_path', 'deb.yml')
+      end
+      
+      it "should be able to backup and replace a file that's already there..." do
+        DpkgTools::Package::Setup.expects(:bootstrap_file_path).with('base_path', 'deb.yml').returns('bootstrap_file_path')
+        File.stubs(:file?).with('bootstrap_file_path').returns(true)
+        
+        FileUtils.expects(:mv).with('bootstrap_file_path', 'bootstrap_file_path.bak')
+        FileUtils.expects(:cp).with('/a/path/to/resources/deb.yml', 'bootstrap_file_path')
+        
+        DpkgTools::Package::Setup.bootstrap_file('base_path', 'deb.yml', :backup => true)
+      end
+    end
+    
+    it ".bootstrap should copy across the files correctly" do
+      DpkgTools::Package::Setup.stubs(:bootstrap_files).returns('deb.yml')
+      DpkgTools::Package::Setup.expects(:bootstrap_file).with('base_path', 'deb.yml')
+      
+      DpkgTools::Package::Setup.bootstrap('base_path')
+    end
+  end
+  
+  describe ".from_path support methods" do
+    it "should provide a for-overriding method to return the Package::Data subclass to use" do
+      DpkgTools::Package::Setup.data_class.should == DpkgTools::Package::Data
+    end
+  end
+  
+  describe ".from_path" do
+    it "should create a DpkgTools::Package::Data instance, and feed it to .new" do
+      DpkgTools::Package::Setup.expects(:needs_bootstrapping?).with('base_path').returns(false)
+      DpkgTools::Package::Data.expects(:new).with('base_path').returns(:data)
+      DpkgTools::Package::Setup.expects(:new).with(:data, 'base_path').returns(:instance)
+                      
+      DpkgTools::Package::Setup.from_path('base_path').should == :instance
+    end
+  
+    it "should be able to bootstrap the rails app if needed" do
+      DpkgTools::Package::Setup.expects(:needs_bootstrapping?).with('base_path').returns(true)
+      DpkgTools::Package::Setup.expects(:bootstrap).with('base_path')
+                      
+      DpkgTools::Package::Data.expects(:new).with('base_path').returns(:data)
+      DpkgTools::Package::Setup.expects(:new).with(:data, 'base_path').returns(:instance)
+                      
+      DpkgTools::Package::Setup.from_path('base_path').should == :instance
+    end
+  end
+end
+
+describe DpkgTools::Package::Setup, "#create_structure" do
+  before(:each) do
+    @data = stub("stub DpkgTools::Package::Data", :name => 'hello', :version => '1')
+    DpkgTools::Package::Config.root_path = '/a/path/to/package/dirs'
+    @config = DpkgTools::Package::Config.new('hello', '1', {})
+    DpkgTools::Package::Config.expects(:new).with('hello', '1', {}).returns(@config)
+    
+    @setup = DpkgTools::Package::Setup.new(@data, :base_path => 'base_path')
+  end
+  
+  it "should be able to provide the options needed for DpkgTools::Package::Config" do
+    @setup.config_options.should == {}
+  end
+  
+  it "should be able to perform all the steps needed to create the package structure" do
+    DpkgTools::Package.expects(:check_package_dir).with(@config)
+    
+    @setup.expects(:prepare_package)
+    @setup.expects(:write_control_files)
+    @setup.expects(:copy_maintainer_script_templates)
+    
+    @setup.create_structure
+  end
+  
+  it "should be able to write out the control files" do
+    mock_control_file = mock('DpkgTools::Package::ControlFile::* instance')
+    mock_control_file.expects(:write)
+    
+    mock_control_file_class = mock('DpkgTools::Package::ControlFile::* class')
+    mock_control_file_class.expects(:new).with(@data, @config).returns(mock_control_file)
+    
+    @setup.expects(:control_file_classes).returns([mock_control_file_class])
+    
+    @setup.write_control_files
+  end
+  
+  it "should be able to return a list of maintainer script template names" do
+    @setup.maintainer_script_template_names.should == ['postinst.erb', 'postrm.erb', 'preinst.erb', 'prerm.erb']
+  end
+  
+  it "should be able to copy across any of the maintainer script templates present in the resources dir" do
+    @data.stubs(:resources_path).returns('/a/path/to/resources')
+    File.expects(:file?).with('/a/path/to/resources/postinst.erb').returns(true)
+    File.expects(:file?).with('/a/path/to/resources/postrm.erb').returns(false)
+    File.expects(:file?).with('/a/path/to/resources/preinst.erb').returns(false)
+    File.expects(:file?).with('/a/path/to/resources/prerm.erb').returns(true)
+    
+    FileUtils.expects(:cp).with('/a/path/to/resources/postinst.erb', '/a/path/to/package/dirs/hello-1/debian/postinst.erb')
+    FileUtils.expects(:cp).with('/a/path/to/resources/prerm.erb', '/a/path/to/package/dirs/hello-1/debian/prerm.erb')
+    
+    @setup.copy_maintainer_script_templates
+  end
+  
+  it "should provide a no-op version of prepare_package" do
+    @setup.should respond_to(:prepare_package)
+  end
+end
+
+describe DpkgTools::Package::Setup, "regenerating control files and maintainer scripts" do
+  before(:each) do
+    @data = stub("stub DpkgTools::Package::Data", :name => 'hello', :version => '1')
+    DpkgTools::Package::Config.root_path = '/a/path/to/package/dirs'
+    @config = DpkgTools::Package::Config.new('hello', '1', {})
+    DpkgTools::Package::Config.expects(:new).with('hello', '1', {}).returns(@config)
+    
+    @setup = DpkgTools::Package::Setup.new(@data, :base_path => 'base_path')
+  end
+  
+  it "should be able to regenerate the control files, saving the existing files to name.bak" do
+    mock_control_file_class = mock('DpkgTools::Package::ControlFile')
+    mock_control_file_class.expects(:new).with(@data, @config).returns(mock_control_file_class)
+    mock_control_file_class.stubs(:needs_reset?).returns(true)
+    mock_control_file_class.stubs(:file_path).returns('/a/path/to/control_file')
+    @setup.stubs(:control_file_classes).returns([mock_control_file_class])
+    
+    mock_control_file_class.expects(:write)
+    File.expects(:exist?).with('/a/path/to/control_file').returns(true)
+    FileUtils.expects(:mv).with('/a/path/to/control_file', '/a/path/to/control_file.bak')
+    @setup.reset_control_files
+  end
+  
+  it "should not bother trying to back up a control file if the file is missing" do
+    mock_control_file_class = mock('DpkgTools::Package::ControlFile')
+    mock_control_file_class.expects(:new).with(@data, @config).returns(mock_control_file_class)
+    mock_control_file_class.stubs(:needs_reset?).returns(true)
+    mock_control_file_class.stubs(:file_path).returns('/a/path/to/control_file')
+    @setup.stubs(:control_file_classes).returns([mock_control_file_class])
+    
+    File.expects(:exist?).with('/a/path/to/control_file').returns(false)
+    mock_control_file_class.expects(:write)
+    @setup.reset_control_files
+  end
+  
+  it "should not try to regenerate a control file which doesn't need it" do
+    mock_control_file_class = mock('DpkgTools::Package::ControlFile')
+    mock_control_file_class.expects(:new).with(@data, @config).returns(mock_control_file_class)
+    mock_control_file_class.stubs(:needs_reset?).returns(false)
+    mock_control_file_class.stubs(:file_path).returns('/a/path/to/control_file')
+    @setup.stubs(:control_file_classes).returns([mock_control_file_class])
+    
+    mock_control_file_class.expects(:write).never
+    @setup.reset_control_files
+  end
+  
+  it "should be able to regenerate maintainer scripts, as needed" do
+    @data.stubs(:resources_path).returns('/a/path/to/resources')
+    File.expects(:file?).with('/a/path/to/resources/postinst.erb').returns(true)
+    File.expects(:file?).with('/a/path/to/resources/postrm.erb').returns(false)
+    File.expects(:file?).with('/a/path/to/resources/preinst.erb').returns(false)
+    File.expects(:file?).with('/a/path/to/resources/prerm.erb').returns(true)
+    
+    FileUtils.expects(:identical?).with('/a/path/to/resources/prerm.erb', 
+                                        '/a/path/to/package/dirs/hello-1/debian/prerm.erb').returns(true)
+    FileUtils.expects(:identical?).with('/a/path/to/resources/postinst.erb', 
+                                         '/a/path/to/package/dirs/hello-1/debian/postinst.erb').returns(false)
+    FileUtils.expects(:mv).with('/a/path/to/package/dirs/hello-1/debian/postinst.erb',
+                                '/a/path/to/package/dirs/hello-1/debian/postinst.erb.bak')
+    FileUtils.expects(:cp).with('/a/path/to/resources/postinst.erb', '/a/path/to/package/dirs/hello-1/debian/postinst.erb')
+    
+    @setup.reset_maintainer_script_templates
+  end
+end