dpkg-tools 0.3.3

data/spec/dpkg-tools/package/control_files/base_spec.rb

@@ -0,0 +1,111 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe DpkgTools::Package::ControlFiles::Base, "writing control files out" do
+  it "should be able to make the target dir" do
+    Dir.expects(:mkdir).with('a_path/debian')
+    File.stubs(:exists?).with('a_path/debian').returns(false)
+
+    DpkgTools::Package::ControlFiles::Base.check_target_dir("a_path/debian")
+  end
+
+  it "should be able to write a file in the debian dir" do
+    DpkgTools::Package::ControlFiles::Base.expects(:check_target_dir).with('a_path/debian')
+    mock_file = mock('Mock file')
+    mock_file.expects(:write).with('file contents')
+    File.expects(:open).with('a_path/debian/filename', 'w').yields(mock_file)
+
+    DpkgTools::Package::ControlFiles::Base.write('a_path/debian/filename', 'file contents')
+  end
+
+  it "should be able to write an executable file in the debian dir" do
+    DpkgTools::Package::ControlFiles::Base.expects(:write).with('a_path/debian/rules', 'file contents')
+    File.expects(:chmod).with(0755, "a_path/debian/rules")
+    DpkgTools::Package::ControlFiles::Base.write_executable('a_path/debian/rules', 'file contents')
+  end
+  
+  it "should be able to return its filename" do
+    DpkgTools::Package::ControlFiles::Base.filename.should == 'base'
+  end
+  
+  it "should be able to return its formatter class" do
+    DpkgTools::Package::ControlFiles::Base.formatter_class.should == DpkgTools::Package::ControlFiles::BaseFormatter
+  end
+end
+
+describe DpkgTools::Package::ControlFiles::Base, "creating instances" do
+  it "should require a data and config object to be passed in" do
+    DpkgTools::Package::ControlFiles::Base.new(:data, :config).should be_an_instance_of(DpkgTools::Package::ControlFiles::Base)
+  end
+  
+  it "should fail if no arguments are passed in" do
+    lambda { DpkgTools::Package::ControlFiles::Base.new }.should raise_error
+  end
+  
+  it "should fail if only one argument is passed in" do
+    lambda { DpkgTools::Package::ControlFiles::Base.new(:data) }.should raise_error
+  end
+end
+
+describe DpkgTools::Package::ControlFiles::Base, "instances" do
+  before(:each) do
+    @config = DpkgTools::Package::Config.new('name', '1.0', :base_path => '/a/path/to/package')
+    @formatter = mock('DpkgTools::Package::ControlFiles::BaseFormatter')
+    DpkgTools::Package::ControlFiles::BaseFormatter.expects(:new).with(anything).returns(@formatter)
+    @control_file = DpkgTools::Package::ControlFiles::Base.new(:data, @config)
+  end
+  
+  it "should use the class' value for filename" do
+    DpkgTools::Package::ControlFiles::Base.expects(:filename).returns(:class_filename)
+    @control_file.filename.should == :class_filename
+  end
+  
+  it "should be able to return its formatter class instance" do
+    @control_file.formatter.should == @formatter
+  end
+  
+  it "should be able to figure out where it should be written" do
+    @control_file.file_path.should == '/a/path/to/package/debian/base'
+  end
+  
+  it "should be able to specify whether to write itself out as an executable" do
+    @control_file.executable?.should be_false
+  end
+  
+  it "should be able to write itself out" do
+    @control_file.expects(:to_s).returns('file contents')
+    DpkgTools::Package::ControlFiles::Base.expects(:write).with('/a/path/to/package/debian/base', 'file contents')
+    
+    @control_file.write
+  end
+  
+  it "should be able to create a string with the file contents in" do
+    @formatter.expects(:build).returns('file contents')
+    
+    @control_file.to_s.should == 'file contents'
+  end
+  
+  it "should be able to tell that the existing control file is different to the one that this instance would generate" do
+    @control_file.expects(:to_s).returns('new file contents')
+    @control_file.stubs(:file_path).returns('/a/path/to/control_file')
+    File.expects(:exist?).with('/a/path/to/control_file').returns(true)
+    File.expects(:read).with('/a/path/to/control_file').returns('file contents')
+    
+    @control_file.needs_reset?.should be_true
+  end
+  
+  it "should be able to tell that the existing control file is the same as the one that this instance would generate" do
+    @control_file.expects(:to_s).returns('file contents')
+    @control_file.stubs(:file_path).returns('/a/path/to/control_file')
+    File.expects(:exist?).with('/a/path/to/control_file').returns(true)
+    File.expects(:read).with('/a/path/to/control_file').returns('file contents')
+    
+    @control_file.needs_reset?.should be_false
+  end
+  
+  it "should know that if a control file is missing then a reset is needed by default" do
+    @control_file.expects(:file_path).returns('/a/path/to/control_file')
+    File.expects(:exist?).with('/a/path/to/control_file').returns(false)
+    
+    @control_file.needs_reset?.should be_true
+  end
+end

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

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe DpkgTools::Package::ControlFiles::Changelog, "generating the debian/control file" do
+  it "should return the correct filename" do
+    DpkgTools::Package::ControlFiles::Changelog.filename.should == 'changelog'
+  end
+  
+  it "should return the correct formatter class" do
+    DpkgTools::Package::ControlFiles::Changelog.formatter_class.
+      should == DpkgTools::Package::ControlFiles::ChangelogFormatter
+  end
+end
+
+describe DpkgTools::Package::ControlFiles::ChangelogFormatter, "Can generate a debian/copyright file" do
+  it "should grab the license_file from the metadata object" do
+    metadata = mock('package metadata object')
+    metadata.expects(:changelog).returns("Changelog file")
+    
+    formatter = DpkgTools::Package::ControlFiles::ChangelogFormatter.new(metadata)
+    formatter.build.should == "Changelog file"
+  end
+end

data/spec/dpkg-tools/package/control_files/control_spec.rb

@@ -0,0 +1,131 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe "generating the debian/control file" do
+  describe DpkgTools::Package::ControlFiles::Control do
+    it "should return the correct filename" do
+      DpkgTools::Package::ControlFiles::Control.filename.should == 'control'
+    end
+
+    it "should return the correct formatter class" do
+      DpkgTools::Package::ControlFiles::Control.formatter_class.
+        should == DpkgTools::Package::ControlFiles::ControlFormatter
+    end
+    
+    describe "instances" do
+      before(:each) do
+        stub_requirement = stub('stub Gem::Requirement', :as_list => [">= 0.0.0"])
+        @mock_dep_list = [stub('stub Gem::Dependency', :name => 'whatagem', :version_requirements => stub_requirement)]
+        @stub_data = stub('stub DpkgTools::Package::Data', 
+                          :build_dependencies => [{:name => "build_dep", :requirements => [">= 0.9.4-1"]}], 
+                          :dependencies => [{:name => "dep", :requirements => [">= 0.9.4-1"]}], 
+                          :summary => "Test gem for testing", :debian_arch => 'i386')
+        @stub_config = DpkgTools::Package::Config.new('gem-name', '1.0.8', :suffix => 'rubygem')
+
+        @control_file = DpkgTools::Package::ControlFiles::Control.new(@stub_data, @stub_config)
+      end
+
+      it "should be able to return the Source: line" do
+        @control_file.source.should == @stub_config.package_name
+      end
+
+      it "should be able to return the Maintainer: line" do
+        @control_file.maintainer.should == ["Matt Patterson", "matt@reprocessed.org"]
+      end
+      it "should be able to generate Build-Depends: line" do
+        @control_file.build_depends.should == @stub_data.build_dependencies
+      end
+
+      it "should be able to generate the Standards-Version: line" do
+        @control_file.standards_version.should == DpkgTools::Package.standards_version
+      end
+
+      it "should be able to generate the Package: line" do
+        @control_file.package.should == @stub_config.package_name
+      end
+
+      it "should be able to generate the Architecture: line" do
+        @control_file.architecture.should == "i386"
+      end
+
+      it "should be able to generate the Depends: line" do
+        @control_file.depends.should == @stub_data.dependencies
+      end
+
+      it "should be able to generate the Essential: line" do
+        @control_file.essential.should == "no"
+      end
+
+      it "should be able to generate the Description: line" do
+        @control_file.description.should == "Test gem for testing"
+      end
+    end
+  end
+
+  describe DpkgTools::Package::ControlFiles::ControlFormatter, "instances" do
+    before(:each) do
+      @metadata = stub("DpkgTools::Package::Blah::ControlFiles::Control", :source => 'source-package-name', 
+                       :package => 'binary-package-name', :maintainer => ["Matt Patterson", "matt@reprocessed.org"])
+      @formatter = DpkgTools::Package::ControlFiles::ControlFormatter.new(@metadata)
+    end
+  
+    it "should be able to return a list of source paragraph fields" do
+      @formatter.source_field_names.should be_an_instance_of(Array)
+    end
+  
+    it "should be able to return a list of binary paragraph fields" do
+      @formatter.binary_field_names.should be_an_instance_of(Array)
+    end
+  
+    it "should be able to map field_names symbols to the .deb format version" do
+      @formatter.field_names_map.should be_an_instance_of(Hash)
+    end
+  
+    it "should be able to correctly construct a Maintainer line" do
+      @formatter.maintainer.should == "Maintainer: Matt Patterson <matt@reprocessed.org>"
+    end
+  
+    it "should be able to turn a list of deps into a correctly formatted string" do
+      deps = [{:name => "a-dependency", :requirements => [">= 0.0.0-1"]}, {:name => "another-dep", :requirements => [">= 0", "<= 1"]}]
+      @formatter.send(:deps_string, deps).should == "a-dependency (>= 0.0.0-1), another-dep (>= 0) (<= 1)"
+    end
+    
+    describe "handling dependencies lines" do
+      it "should iterate across the control file field names and insert any lines represented by methods in the metadata object" do
+        metadata = stub('Gem::ControlFilesData::Control instance', :source => 'source-package-name', :package => 'binary-package-name')
+
+        formatter = DpkgTools::Package::ControlFiles::ControlFormatter.new(metadata)
+        formatter.build.should == "Source: source-package-name\n\nPackage: binary-package-name\n"
+      end
+
+      it "should be able to correctly construct a dependencies line" do
+        metadata = stub('package metadata object', :depends => [{:name => "dependency", :requirements => [">= 1.0.0-1"]}])
+
+        formatter = DpkgTools::Package::ControlFiles::ControlFormatter.new(metadata)
+        formatter.send(:depends_line, :depends).should == "Depends: dependency (>= 1.0.0-1)"
+      end
+
+      it "should be able to correctly construct a dependencies line which has no requirements" do
+        metadata = stub('package metadata object', :depends => [{:name => "dependency", :requirements => []}])
+
+        formatter = DpkgTools::Package::ControlFiles::ControlFormatter.new(metadata)
+        formatter.send(:depends_line, :depends).should == "Depends: dependency"
+      end
+
+      it "should be able to correctly construct a dependencies line which has requirements unset" do
+        metadata = stub('package metadata object', :depends => [{:name => "dependency"}])
+
+        formatter = DpkgTools::Package::ControlFiles::ControlFormatter.new(metadata)
+        formatter.send(:depends_line, :depends).should == "Depends: dependency"
+      end
+
+      it "should be able to handle fields which need special processing by calling the local method and handing off the metadata to that" do
+        metadata = stub('package metadata object', :depends => [{:name => "dependency", :requirements => [">= 1.0.0-1"]}])
+        formatter = DpkgTools::Package::ControlFiles::ControlFormatter.new(metadata)
+
+        formatter.expects(:depends_line).with(:depends).returns("Here is a depends line")
+
+        formatter.build.should == "\nHere is a depends line\n"
+      end
+    end
+  end
+end

data/spec/dpkg-tools/package/control_files/copyright_spec.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe DpkgTools::Package::ControlFiles::Copyright, "generating the debian/control file" do
+  it "should return the correct filename" do
+    DpkgTools::Package::ControlFiles::Copyright.filename.should == 'copyright'
+  end
+  
+  it "should return the correct formatter class" do
+    DpkgTools::Package::ControlFiles::Copyright.formatter_class.
+      should == DpkgTools::Package::ControlFiles::CopyrightFormatter
+  end
+  
+  it "should be able to locate and return the app's license" do
+    stub_data = stub('stub DpkgTools::Package::Data', :license => "(c) Matt Patterson 2007, All rights reserved")
+    metadata = DpkgTools::Package::ControlFiles::Copyright.new(stub_data, :config)
+    
+    metadata.license_file.should == "(c) Matt Patterson 2007, All rights reserved"
+  end
+end
+
+describe DpkgTools::Package::ControlFiles::CopyrightFormatter, "Can generate a debian/copyright file" do
+  it "should grab the license_file from the metadata object" do
+    metadata = mock('package metadata object')
+    metadata.expects(:license_file).returns("License file")
+    
+    formatter = DpkgTools::Package::ControlFiles::CopyrightFormatter.new(metadata)
+    formatter.build.should == "License file"
+  end
+end

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

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe DpkgTools::Package::ControlFiles::Rakefile, "generating the debian/control file" do
+  it "should return the correct filename" do
+    DpkgTools::Package::ControlFiles::Rakefile.filename.should be_nil
+  end
+  
+  it "should return the correct formatter class" do
+    DpkgTools::Package::ControlFiles::Rakefile.formatter_class.
+      should == DpkgTools::Package::ControlFiles::RakefileFormatter
+  end
+end
+
+describe DpkgTools::Package::ControlFiles::Rakefile, "instances" do
+  it "should generate the correct path" do
+    data = mock('DpkgTools::Package::Data')
+    data.expects(:rakefile_location).returns([:base_path, 'Rakefile'])
+    config = mock('DpkgTools::Package::Config')
+    config.expects(:base_path).returns('/a/path/to')
+    
+    control_file = DpkgTools::Package::ControlFiles::Rakefile.new(data, config)
+    control_file.file_path.should == '/a/path/to/Rakefile'
+  end
+end
+
+describe DpkgTools::Package::ControlFiles::RakefileFormatter, "Can generate a debian/copyright file" do
+  before(:each) do
+    @metadata = mock('package metadata object')
+    @metadata.expects(:rakefile).returns("Rakefile")
+    
+    @formatter = DpkgTools::Package::ControlFiles::RakefileFormatter.new(@metadata)
+  end
+  
+  it "should grab the license_file from the metadata object" do
+    @formatter.build.should == "Rakefile"
+  end
+end

data/spec/dpkg-tools/package/control_files/rules_spec.rb

@@ -0,0 +1,16 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe DpkgTools::Package::ControlFiles::Rules, "generating the debian/control file" do
+  it "should return the correct filename" do
+    DpkgTools::Package::ControlFiles::Rules.filename.should == 'rules'
+  end
+  
+  it "should be an executable file" do
+    DpkgTools::Package::ControlFiles::Rules.new(:data, :config).executable?.should be_true
+  end
+  
+  it "should return the correct formatter class" do
+    DpkgTools::Package::ControlFiles::Rules.formatter_class.
+      should == DpkgTools::Package::ControlFiles::RulesFormatter
+  end
+end

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

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe DpkgTools::Package::ControlFiles, ".classes" do
+  it "should return the control file classes in an array" do
+    DpkgTools::Package::ControlFiles.classes.
+      should == [DpkgTools::Package::ControlFiles::Changelog,
+                 DpkgTools::Package::ControlFiles::Control,
+                 DpkgTools::Package::ControlFiles::Copyright,
+                 DpkgTools::Package::ControlFiles::Rakefile,
+                 DpkgTools::Package::ControlFiles::Rules]
+  end
+end

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

@@ -0,0 +1,115 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe DpkgTools::Package::Data, "instances" do
+  before(:each) do
+    @data = DpkgTools::Package::Data.new
+  end
+  
+  it "should provide public access to a binding object of their context" do
+    @data.binding.should be_an_instance_of(Binding)
+  end
+  
+  it "should provide access to the path of the resources dir in the gem" do
+    DpkgTools::Package::Data.resources_path.should == File.expand_path(File.dirname(__FILE__) + '/../../../resources/data')
+  end
+  
+  it "should provide access to the name of the resources subdir in the gem" do
+    DpkgTools::Package::Data.resources_dirname.should == 'data'
+  end
+  
+  it "should provide access to the resources_path class method on instances" do
+    @data.resources_path.should == DpkgTools::Package::Data.resources_path
+  end
+  
+  it "should be able to say that it's an architecture-independent package when it is" do
+    @data.stubs(:debian_arch).returns('all')
+    @data.architecture_independent?.should be_true
+  end
+  
+  it "should be able to say that it isn't an architecture-independent package when it isn't" do
+    @data.stubs(:debian_arch).returns('i386')
+    @data.architecture_independent?.should be_false
+  end
+end
+
+describe DpkgTools::Package::Data::YamlConfigHelpers do
+  before(:each) do
+    @module = Module.new
+    @module.extend(DpkgTools::Package::Data::YamlConfigHelpers)
+  end
+  
+  describe ".load_package_data" do
+    it "should be able to figure out the path to a given .yml file" do
+      @module.package_data_file_path('base_path', 'deb.yml').should == 'base_path/deb.yml'
+    end
+    
+    it "should be able to read in the config/*.yml file" do
+      File.expects(:exist?).with('base_path/deb.yml').returns(true)
+      YAML.expects(:load_file).with('base_path/deb.yml').returns({"name" => 'rails-app'})
+      @module.load_package_data('base_path', 'deb.yml').should == {"name" => 'rails-app'}
+    end
+  end
+  
+  describe ".process_dependencies" do
+    it "should report the base deps if the YAML says no deps at all" do
+      fixture_data = {'name' => 'rails-app', 'version' => '1.0.8', 'license' => '(c) Matt 4evah'}
+      
+      @module.expects(:base_gem_deps).returns([:dep_the_first])
+      @module.expects(:base_package_deps).returns([:dep_the_other])
+      @module.process_dependencies(fixture_data).
+        should have_the_same_contents_as([:dep_the_first, :dep_the_other])
+    end
+
+    it "should report base deps plus gem deps if they're specified" do
+      fixture_data = {'dependencies' => {'gem' => ['rspec' => ['>= 1.0.8']]}}
+
+      @module.process_dependencies(fixture_data).
+        should include({:name => 'rspec-rubygem', :requirements => ['>= 1.0.8-1']})
+    end
+
+    it "should report base deps plus package deps if they're specified" do
+      fixture_data = {'dependencies' => {'package' => ['rspec' => ['>= 1.0.8']]}}
+
+      @module.process_dependencies(fixture_data).
+        should include({:name => 'rspec', :requirements => ['>= 1.0.8']})
+    end
+
+    it "should be able to report base deps plus any other deps..." do
+      fixture_data = {'dependencies' => {'gem' => ['rspec' => ['>= 1.0.8']],
+                      'package' => ['rspec' => ['>= 1.0.8']]}}
+      deps = @module.process_dependencies(fixture_data)
+      deps.should include({:name => 'rspec-rubygem', :requirements => ['>= 1.0.8-1']}) 
+      deps.should include({:name => 'rspec', :requirements => ['>= 1.0.8']})
+    end
+
+    it "should be able to cope with deps whose version requirements are specified by a single string" do
+      fixture_data = {'dependencies' => {'gem' => ['rspec' => '>= 1.0.8']}}
+
+      @module.process_dependencies(fixture_data).
+        should include({:name => 'rspec-rubygem', :requirements => ['>= 1.0.8-1']})
+    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
+    it "should raise an appropriate error if the dependencies gem sequence isn't a sequence" do
+      fixture_data = {'gem' => 'string'}
+
+      lambda { @module.process_dependencies_by_type(fixture_data, 'gem') }.
+        should raise_error(DpkgTools::Package::DebYAMLParseError)
+    end
+
+    it "should raise an appropriate error if one of package dependencies version requirements list isn't a list or a string..." do
+      fixture_data = {'package' => ['rspec' => {'>= 1.0.8' => 'blah'}]}
+
+      lambda { @module.process_dependencies_by_type(fixture_data, 'package') }.
+        should raise_error(DpkgTools::Package::DebYAMLParseError)
+    end
+  end
+end