dpkg-tools 0.3.3

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

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/../../../../spec_helper'
+
+describe DpkgTools::Package::Gem::ControlFiles::Changelog, "#changelog" do
+  before(:each) do
+    config = DpkgTools::Package::Config.new('gem-name', '1.0.8', :suffix => 'rubygem')
+    stub_data = stub('DpkgTools::Package::Gem::Data', :full_name => 'gem-name-1.0.8', :debian_revision => '1')
+    @metadata = DpkgTools::Package::Gem::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 == "gem-name-rubygem (1.0.8-1) cp-gutsy; urgency=low\n"\
+    "  * Packaged up gem-name-1.0.8\n"\
+    " -- Matt Patterson <matt@reprocessed.org>  RFC 822 change time\n"
+  end
+end

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

@@ -0,0 +1,28 @@
+require File.dirname(__FILE__) + '/../../../../spec_helper'
+
+describe DpkgTools::Package::Gem::ControlFiles::Copyright, "#license_file" do
+  it "should be able to locate and return the Gem's license file" do
+    stub_data = stub('stub DpkgTools::Package::Gem::Data', :files => ["LICENSE"], 
+                     :file_entries => [[{"path" => "LICENSE"}, "License file text"]])
+    metadata = DpkgTools::Package::Gem::ControlFiles::Copyright.new(stub_data, :config)
+    
+    metadata.license_file.should == "License file text"
+  end
+  
+  it "should be able to cope with nil entries in data.files (as seen in the mysql gem)" do
+    stub_data = stub('stub DpkgTools::Package::Gem::Data', :files => ["LICENSE", nil], 
+                     :file_entries => [[{"path" => "LICENSE"}, "License file text"]])
+    metadata = DpkgTools::Package::Gem::ControlFiles::Copyright.new(stub_data, :config)
+    
+    metadata.license_file.should == "License file text"
+  end
+  
+  it "should be able to locate licenses called COPYING" do
+    stub_data = stub('stub DpkgTools::Package::Gem::Data', :files => ["COPYING"], 
+                     :file_entries => [[{"path" => "COPYING"}, "License file text"]])
+    metadata = DpkgTools::Package::Gem::ControlFiles::Copyright.new(stub_data, :config)
+    
+    metadata.license_file.should == "License file text"
+  end
+end
+

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

@@ -0,0 +1,17 @@
+require File.dirname(__FILE__) + '/../../../../spec_helper'
+
+describe DpkgTools::Package::Gem::ControlFiles::Rakefile do
+  it "should be able to generate the contents of the Rakefile" do
+    config = DpkgTools::Package::Config.new("gem-name", "1.0.8", :suffix => 'rubygem')
+    stub_data = stub("DpkgTools::Package::Gem::Data", :full_name => "gem-name-1.0.8")
+    metadata = DpkgTools::Package::Gem::ControlFiles::Rakefile.new(stub_data, config)
+    
+    metadata.rakefile.should == "require 'rubygems'\n" \
+    "require 'dpkg-tools'\n" \
+    "\n" \
+    "DpkgTools::Package::Gem::BuildTasks.new do |t|\n" \
+    "  t.root_path = File.dirname(Rake.original_dir)\n" \
+    "  t.gem_path = File.join(Rake.original_dir, 'gem-name-1.0.8.gem')\n" \
+    "end\n"
+  end
+end

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

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

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

@@ -0,0 +1,176 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe DpkgTools::Package::Gem::Data do
+  it "should report its resources_dirname correctly" do
+    DpkgTools::Package::Gem::Data.resources_dirname.should == 'gem'
+  end
+end
+
+describe DpkgTools::Package::Gem::Data, ".native_extension_deps (managing c-library deps for gems which compile native extensions)" do
+  it "should be able to retrieve a list of deps given a gem name and version number" do
+    DpkgTools::Package::Gem::Data.stubs(:native_extensions_deps_map).returns({'name' => {'1.0.8' => [{:name => 'package-devel'}]}})
+    DpkgTools::Package::Gem::Data.native_extension_deps('name', '1.0.8').should == [{:name => 'package-devel'}]
+  end
+  
+  it "should be able to retrieve a list of deps given a gem name and version number even if no specific deps for that version exist" do
+    DpkgTools::Package::Gem::Data.stubs(:native_extensions_deps_map).returns({'name' => {'all' => [{:name => 'package-devel'}]}})
+    DpkgTools::Package::Gem::Data.native_extension_deps('name', '1.0.8').should == [{:name => 'package-devel'}]
+  end
+end
+
+describe DpkgTools::Package::Gem::Data, ".native_extensions_deps_map (managing c-library deps for gems which compile native extensions)" do
+  it "should load its map of gems with native extensions -> deps from a YAML file" do
+    DpkgTools::Package::Gem::Data.stubs(:resources_path).returns('/a/path/to')
+    YAML.expects(:load_file).with('/a/path/to/gems_to_deps.yml').returns(:hash)
+    DpkgTools::Package::Gem::Data.expects(:process_extensions_map).with(:hash).returns(:hash)
+    DpkgTools::Package::Gem::Data.native_extensions_deps_map.should == :hash
+  end
+  
+  it "should cache the result of process_extensions_map" do
+    DpkgTools::Package::Gem::Data.send(:remove_instance_variable, :@native_extensions_deps_map)
+    YAML.stubs(:load_file).returns(:hash)
+    DpkgTools::Package::Gem::Data.expects(:process_extensions_map).with(:hash).returns(:hash)
+    DpkgTools::Package::Gem::Data.native_extensions_deps_map.should == :hash
+    DpkgTools::Package::Gem::Data.native_extensions_deps_map.should == :hash
+  end
+end
+
+describe DpkgTools::Package::Gem::Data, ".process_extensions_map (managing c-library deps for gems which compile native extensions)" do
+  it "should be able to process a gem entry with a single specific version with a single dep" do
+    input_hash =  {'name' => {'1.0.8' => 'dep'}}
+    DpkgTools::Package::Gem::Data.process_extensions_map(input_hash).should == {'name' => {'1.0.8' => [{:name => 'dep'}]}}
+  end
+  
+  it "should be able to process a gem entry with a single specific version with multiple deps" do
+    input_hash =  {'name' => {'1.0.8' => ['dep1', 'dep2']}}
+    DpkgTools::Package::Gem::Data.process_extensions_map(input_hash).should == {'name' => {'1.0.8' => [{:name => 'dep1'}, {:name => 'dep2'}]}}
+  end
+  
+  it "should be able to process a gem entry with a single dep" do
+    input_hash =  {'name' => 'dep'}
+    DpkgTools::Package::Gem::Data.process_extensions_map(input_hash).should == {'name' => {'all' => [{:name => 'dep'}]}}
+  end
+  
+  it "should be able to process a gem entry with multiple deps" do
+    input_hash =  {'name' => ['dep1', 'dep2']}
+    DpkgTools::Package::Gem::Data.process_extensions_map(input_hash).should == {'name' => {'all' => [{:name => 'dep1'}, {:name => 'dep2'}]}}
+  end
+  
+  it "should be able to process a gem entry with a single dep" do
+    input_hash =  {'name' => 'dep'}
+    DpkgTools::Package::Gem::Data.process_extensions_map(input_hash).should == {'name' => {'all' => [{:name => 'dep'}]}}
+  end
+  
+  it "should be able to process a gem entry with multiple deps" do
+    input_hash =  {'name' => ['dep1', 'dep2']}
+    DpkgTools::Package::Gem::Data.process_extensions_map(input_hash).should == {'name' => {'all' => [{:name => 'dep1'}, {:name => 'dep2'}]}}
+  end
+  
+  it "should be able to process a gem entry where the version is processed into a Float" do
+    input_hash =  {'name' => {1.0 => 'dep'}}
+    DpkgTools::Package::Gem::Data.process_extensions_map(input_hash).should == {'name' => {'1.0' => [{:name => 'dep'}]}}
+  end
+  
+  it "should be able to process a gem entries with multiple deps and a mixed style" do
+    input_hash =  {'mysql' => {2.6 => 'libmysqlclient-dev', 2.7 => ['libmysqlclient-dev', 'other-dep']}}
+    expected_hash = {'mysql' => {'2.6' => [{:name => 'libmysqlclient-dev'}], '2.7' => [{:name => 'libmysqlclient-dev'}, {:name => 'other-dep'}]}}
+    DpkgTools::Package::Gem::Data.process_extensions_map(input_hash).should == expected_hash
+  end
+end
+
+describe DpkgTools::Package::Gem::Data, ".new" do
+  it "should raise an error without any arguments" do
+    lambda { DpkgTools::Package::Gem::Data.new }.should raise_error
+  end
+  
+  it "should require one argument" do
+    version = stub('Version', :to_s => '1.0.8')
+    stub_spec = stub("stub Gem::Specification", :name => 'gem_name', :version => version, 
+                                                :full_name => 'gem_name-1.0.8', :dependencies => :deps,
+                                                :summary => 'A gem', :files => :files)
+    stub_format = stub('stub Gem::Format', :spec => stub_spec)
+    
+    DpkgTools::Package::Gem::Data.new(stub_format, 'gem_byte_string')
+  end
+end
+
+describe DpkgTools::Package::Gem::Data, "instances" do
+  before(:each) do
+    DpkgTools::Package::Config.root_path = '/a/path/to'
+    version = stub('Version', :to_s => '1.0.8')
+    stub_requirement = stub('stub Gem::Requirement', :as_list => [">= 0.0.0"])
+    @mock_dep_list = [stub('stub Gem::Dependency', :name => 'whatagem', :version_requirements => stub_requirement)]
+    @spec = stub("stub Gem::Specification", :name => 'gem_name', :version => version, 
+                                            :full_name => 'gem_name-1.0.8', :dependencies => @mock_dep_list,
+                                            :summary => 'A gem', :files => :files, :extensions => [])
+    @format = stub("stub Gem::Format", :spec => @spec, :file_entries => :file_entries)
+    @data = DpkgTools::Package::Gem::Data.new(@format, 'gem_byte_string')
+  end
+  
+  it "should provide access to its gem_byte_string" do
+    @data.gem_byte_string.should == 'gem_byte_string'
+  end
+  
+  it "should provide access to their Gem::Spec" do
+    @data.spec.should == @spec
+  end
+  
+  it "should provide access to its name" do
+    @data.name.should == 'gem_name'
+  end
+  
+  it "should convert the Gem::Version object to a string" do
+    @data.version.should == '1.0.8'
+  end
+  
+  it "should provide access to its full_name" do
+    @data.full_name.should == 'gem_name-1.0.8'
+  end
+  
+  it "should provide access to the Gem::Format's file_entries attribute" do
+    @data.file_entries.should == :file_entries
+  end
+  
+  it "should provide access to the Gem::Specification's files attribute" do
+    @data.files.should == :files
+  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 report the debian architecture name as i386 if spec.extensions is not empty" do
+    @spec.stubs(:extensions).returns(['extconf.rb'])
+    @data.debian_arch.should == "i386"
+  end
+  
+  it "should be able to generate a sensible list of deps" do
+    @data.send(:base_deps).should == [{:name => "whatagem-rubygem", :requirements => [">= 0.0.0-1"]}]
+  end
+  
+  it "should provide access to any install-time dependencies" do
+    @data.dependencies.should == [{:name => "rubygems", :requirements => [">= 0.9.4-1"]},
+                                  {:name => "whatagem-rubygem", :requirements => [">= 0.0.0-1"]}]
+  end
+  
+  it "should provide access to any build-time dependencies" do
+    DpkgTools::Package::Gem::Data.stubs(:native_extension_deps).with('gem_name', '1.0.8').returns([{:name => 'libblah-devel'}])
+    @data.build_dependencies.should == [{:name => "rubygems", :requirements => [">= 0.9.4-1"]},
+                                        {:name => "rake-rubygem", :requirements => [">= 0.7.0-1"]},
+                                        {:name => "dpkg-tools-rubygem", :requirements => [">= #{DpkgTools::VERSION::STRING}-1"]},
+                                        {:name => "whatagem-rubygem", :requirements => [">= 0.0.0-1"]},
+                                        {:name => 'libblah-devel'}]
+  end
+  
+  it "should provide access to the summary from the spec" do
+    @data.summary.should == @spec.summary
+  end
+  
+  it "should provide access to the information DpkgTools::Package::Config needs to generate the package Rakefile's path" do
+    @data.rakefile_location.should == [:base_path, 'Rakefile']
+  end
+end

data/spec/dpkg-tools/package/gem/gem_format_spec.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require File.dirname(__FILE__) + '/../../../../lib/dpkg-tools/package/gem/gem_format'
+
+describe DpkgTools::Package::Gem::GemFormat do
+  before(:each) do
+    klass = Class.new
+    klass.send(:include, DpkgTools::Package::Gem::GemFormat)
+    @module = klass.new
+  end
+  
+  describe "creating Gem::Format objects" do
+    it "should be able to turn a byte string of a gem into a Gem::Format" do
+      StringIO.expects(:new).with('gem_byte_string').returns(:string_io)
+      Gem::Format.expects(:from_io).with(:string_io)
+    
+      @module.format_from_string('gem_byte_string')
+    end
+    
+    it "should be able to turn an old-format gem's byte string into a Gem::OldFormat" do
+      StringIO.expects(:new).with(anything).returns(:string_io)
+      Gem::OldFormat.expects(:from_io).with(:string_io)
+      
+      @module.format_from_string(File.read(File.dirname(__FILE__) + '/../../../fixtures/BlueCloth-1.0.0.gem'))
+    end
+  end
+end

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

@@ -0,0 +1,102 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'rake'
+
+describe DpkgTools::Package::Gem::BuildTasks, "task creation" do
+  it "check_setup should be fine if base_path is defined" do
+    DpkgTools::Package::Gem::BuildTasks.any_instance.stubs(:define_tasks)
+    DpkgTools::Package::Gem::BuildTasks.any_instance.stubs(:define_base_tasks)
+    
+    result = DpkgTools::Package::Gem::BuildTasks.new do |t| 
+      t.gem_path = 'gem_path'
+      t.root_path = 'root_path'
+    end
+    result.gem_path.should == 'gem_path'
+    result.root_path.should == 'root_path'
+  end
+  
+  it "should raise an error if gem_path and root_path haven't been defined" do
+    lambda { DpkgTools::Package::Gem::BuildTasks.new }.should raise_error(ArgumentError)
+  end
+  
+  it "should set DpkgTools::Package::Config.root_path correctly" do
+    DpkgTools::Package::Gem::BuildTasks.any_instance.stubs(:define_tasks)
+    DpkgTools::Package::Gem::BuildTasks.any_instance.stubs(:define_base_tasks)
+    
+    DpkgTools::Package::Config.expects(:root_path=).with('root_path')
+    
+    DpkgTools::Package::Gem::BuildTasks.new do |t| 
+      t.gem_path = 'gem_path'
+      t.root_path = 'root_path'
+    end
+  end
+  
+  it "should define the needed tasks" do
+    build_tasks = DpkgTools::Package::Gem::BuildTasks.new do |t| 
+      t.gem_path = 'gem_path'
+      t.root_path = 'root_path'
+    end
+    
+    build_tasks.expects(:task).with("binary-arch")
+    build_tasks.expects(:task).with("binary-indep")
+    build_tasks.expects(:task).with("build-arch")
+    build_tasks.expects(:task).with("build-indep")
+    
+    build_tasks.define_tasks
+  end
+  
+  it "should be able to return a properly instantiated Builder from create_builder" do
+    build_tasks = DpkgTools::Package::Gem::BuildTasks.new do |t| 
+      t.gem_path = 'gem_path'
+      t.root_path = 'root_path'
+    end
+    
+    DpkgTools::Package::Gem.expects(:create_builder).with('gem_path').returns(:builder)
+    
+    build_tasks.create_builder.should == :builder
+  end
+end
+
+describe DpkgTools::Package::Gem::BuildTasks, "rake tasks" do
+  before(:each) do
+    @rake = Rake::Application.new
+    Rake.application = @rake
+    
+    @build_tasks = DpkgTools::Package::Gem::BuildTasks.new do |t| 
+      t.gem_path = "path/to/gem_file.gem"
+      t.root_path = "path"
+    end
+  end
+  
+  after(:each) do
+    Rake.application = nil
+  end
+  
+  it "should properly call the DpkgTools::Package::Gem.create_builder from the task 'binary-arch'" do
+    mock_builder = mock('mock DpkgTools::Package::Gem::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::Gem.create_builder from the task 'binary-indep'" do
+    mock_builder = mock('mock DpkgTools::Package::Gem::Builder')
+    mock_builder.expects(:binary_package)
+    @build_tasks.expects(:create_builder).returns(mock_builder)
+    @rake["binary-indep"].invoke
+  end
+  
+  it "should properly call the DpkgTools::Package::Gem.create_builder from the task 'build-arch'" do
+    mock_builder = mock('mock DpkgTools::Package::Gem::Builder')
+    mock_builder.expects(:build_package)
+    @build_tasks.expects(:create_builder).returns(mock_builder)
+    @rake["build-arch"].invoke
+  end
+  
+  it "should properly call the DpkgTools::Package::Gem.create_builder from the task 'build-indep'" do
+    mock_builder = mock('mock DpkgTools::Package::Gem::Builder')
+    mock_builder.expects(:build_package)
+    @build_tasks.expects(:create_builder).returns(mock_builder)
+    @rake["build-indep"].invoke
+  end
+end

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

@@ -0,0 +1,274 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe DpkgTools::Package::Gem::Setup do
+  # it "should be able to create the .orig.tar.gz containing a correctly named folder and the .gem" do
+  #   # not really sure how to test this meaningfully
+  #   #DpkgTools::Package::Gem.write_orig_tarball
+  # end
+  
+  it "should be able to write a .gem file to the correct place" do
+    config = stub("DpkgTools::Package::Config", :gem_path => 'a/path/to/.gem')
+    mock_file = mock('mock File')
+    mock_file.expects(:write).with('gem byte string')
+    File.expects(:open).with('a/path/to/.gem', 'wb').yields(mock_file)
+    
+    DpkgTools::Package::Gem::Setup.write_gem_file(config, 'gem byte string')
+  end
+  
+  it "should be able to retrieve a gem given its URL" do
+    Gem::RemoteFetcher.fetcher.expects(:fetch_path).with(:uri).returns(:gem_byte_string)
+    DpkgTools::Package::Gem::Setup.gem_file_from_uri(:uri).should == :gem_byte_string
+  end
+  
+  it "should be able to retrieve the latest Gem:::Platform::RUBY version from a list of specs and sources " do
+    specs_n_sources = [[stub('spec', :platform => Gem::Platform::WIN32), 'a_uri'], 
+                       [stub('spec', :platform => Gem::Platform::RUBY), 'a_second_uri'],
+                       [stub('spec', :platform => Gem::Platform::RUBY), 'a_third_uri']]
+                       
+    DpkgTools::Package::Gem::Setup.most_recent_spec_n_source(specs_n_sources)[1].should == 'a_second_uri'
+  end
+  
+  it "should be able to retrieve the latest version where @spec.platform is unset (where it notionally defaults to RUBY)" do
+    specs_n_sources = [[stub('spec', :platform => Gem::Platform::WIN32), 'a_uri'], 
+                       [stub('spec', :platform => nil), 'a_second_uri'],
+                       [stub('spec', :platform => nil), 'a_third_uri']]
+                       
+    DpkgTools::Package::Gem::Setup.most_recent_spec_n_source(specs_n_sources)[1].should == 'a_second_uri'
+  end
+  
+  it "should be able to retrieve specs and sources for a named gem" do
+    mock_installer = mock('mock Gem::RemoteInstaller instance')
+    mock_installer.expects(:specs_n_sources_matching).with('gem_name', anything).returns(:specs_n_sources)
+    Gem::RemoteInstaller.expects(:new).returns(mock_installer)
+    
+    DpkgTools::Package::Gem::Setup.specs_n_sources_for_name('gem_name').should == :specs_n_sources
+  end
+  
+  it "should be able to retrieve the most recent spec and source uri for a named gem" do
+    DpkgTools::Package::Gem::Setup.expects(:most_recent_spec_n_source).with(:specs_n_sources).returns(:most_recent)
+    DpkgTools::Package::Gem::Setup.expects(:specs_n_sources_for_name).with('gem_name').returns(:specs_n_sources)
+    
+    DpkgTools::Package::Gem::Setup.spec_n_source_for_name('gem_name').should == :most_recent
+  end
+  
+  it "should retrieve the Gem::Format and bytes for a gem given a path to the .gem file" do
+    File.expects(:read).with('path/to/package.gem').returns('gem byte string')
+    DpkgTools::Package::Gem::Setup.expects(:format_from_string).with('gem byte string').returns(:format)
+    
+    DpkgTools::Package::Gem::Setup.format_and_file_from_path('path/to/package.gem').should == [:format, 'gem byte string']
+  end
+  
+  it "should be able to create a new instance from a spec and source" do
+    DpkgTools::Package::Gem::Setup.expects(:gem_uri_from_spec_n_source).with(:spec, 'source_uri').returns('http://a/uri/to/gem_name.gem')
+    DpkgTools::Package::Gem::Setup.expects(:gem_file_from_uri).with('http://a/uri/to/gem_name.gem').returns('gem byte string')
+    DpkgTools::Package::Gem::Setup.expects(:format_from_string).with('gem byte string').returns(:format)
+    
+    DpkgTools::Package::Gem::Data.expects(:new).with(:format, 'gem byte string').returns(:data)
+    
+    DpkgTools::Package::Gem::Setup.expects(:new).with(:data).returns(:instance)
+    
+    DpkgTools::Package::Gem::Setup.from_spec_and_source(:spec, 'source_uri').should == :instance
+  end
+  
+  it "should be able to create a new instance from a spec and source via the cache" do
+    DpkgTools::Package::Gem::Setup.expects(:cache_key_from_spec).with(:spec).returns('gem_name-1.0.8')
+    
+    DpkgTools::Package::Gem::Setup.dependency_cache.expects(:has_key?).with('gem_name-1.0.8').returns(false)
+    
+    DpkgTools::Package::Gem::Setup.expects(:from_spec_and_source).with(:spec, 'source_uri').returns(:instance)
+    
+    DpkgTools::Package::Gem::Setup.from_spec_and_source_via_cache(:spec, 'source_uri').should == :instance
+  end
+  
+  it "should be able to create a new instance given a gem name, complete with DpkgTools::Package::Gem::Data" do
+    DpkgTools::Package::Gem::Setup.expects(:spec_n_source_for_name).with('gem_name').returns([:spec, 'source_uri'])
+    DpkgTools::Package::Gem::Setup.expects(:from_spec_and_source_via_cache).with(:spec, 'source_uri').returns(:instance)
+    
+    DpkgTools::Package::Gem::Setup.from_name('gem_name').should == :instance
+  end
+  
+  it "should be able to return an instance from the cache after a cache hit from a spec and source" do
+    DpkgTools::Package::Gem::Setup.expects(:cache_key_from_spec).with(:spec).returns('gem_name-1.0.8')
+    
+    DpkgTools::Package::Gem::Setup.dependency_cache.expects(:has_key?).with('gem_name-1.0.8').returns(true)
+    DpkgTools::Package::Gem::Setup.dependency_cache.expects(:[]).with('gem_name-1.0.8').returns(:instance)
+    DpkgTools::Package::Gem::Setup.from_spec_and_source_via_cache(:spec, 'source_uri').should == :instance
+  end
+  
+  it "should be able to create a new instance, complete with DpkgTools::Package::Gem::Data, given a path to a .gem" do
+    DpkgTools::Package::Gem::Data.expects(:new).with(:format, 'gem byte string').returns(:data)
+    DpkgTools::Package::Gem::Setup.expects(:new).with(:data).returns(:instance)
+    DpkgTools::Package::Gem::Setup.expects(:format_and_file_from_path).with('path/to/package.gem').returns([:format, 'gem byte string'])
+    
+    DpkgTools::Package::Gem::Setup.from_path('path/to/package.gem').should == :instance
+  end
+  
+  it "should be able to return the most recent spec_n_source that satisfies a Gem::Requirement from a spec_n_source" do
+    specs_n_sources = [[stub('spec', :platform => Gem::Platform::WIN32, :version => Gem::Version.create('1.1.8')), 'a_uri'], 
+                       [stub('spec', :platform => Gem::Platform::RUBY, :version => Gem::Version.create('1.1.8')), 'a_second_uri'],
+                       [stub('spec', :platform => Gem::Platform::RUBY, :version => Gem::Version.create('1.1.0')), 'a_third_uri'],
+                       [stub('spec', :platform => Gem::Platform::WIN32, :version => Gem::Version.create('1.0.8')), 'a_fourth_uri'],
+                       [stub('spec', :platform => Gem::Platform::RUBY, :version => Gem::Version.create('1.0.8')), 'a_fifth_uri'],
+                       [stub('spec', :platform => Gem::Platform::RUBY, :version => Gem::Version.create('1.0.2')), 'a_sixth_uri'],
+                       [stub('spec', :platform => Gem::Platform::RUBY, :version => Gem::Version.create('0.9.8')), 'a_seventh_uri']]
+    
+    requirement = Gem::Requirement.create(['< 1.1.0', '>= 1.0.0'])
+    
+    DpkgTools::Package::Gem::Setup.most_recent_spec_n_source_satisfying_requirement(requirement, specs_n_sources)[1].
+      should == 'a_fifth_uri'
+  end
+  
+  it "should be able to return the most recent spec_n_source that satisfies a Gem::Requirement from a spec_n_source, even when spec.platform is unset " do
+    specs_n_sources = [[stub('spec', :platform => Gem::Platform::WIN32, :version => Gem::Version.create('1.1.8')), 'a_uri'], 
+                       [stub('spec', :platform => Gem::Platform::RUBY, :version => Gem::Version.create('1.1.8')), 'a_second_uri'],
+                       [stub('spec', :platform => nil, :version => Gem::Version.create('1.1.0')), 'a_third_uri'],
+                       [stub('spec', :platform => Gem::Platform::WIN32, :version => Gem::Version.create('1.0.8')), 'a_fourth_uri'],
+                       [stub('spec', :platform => nil, :version => Gem::Version.create('1.0.8')), 'a_fifth_uri'],
+                       [stub('spec', :platform => Gem::Platform::RUBY, :version => Gem::Version.create('1.0.2')), 'a_sixth_uri'],
+                       [stub('spec', :platform => Gem::Platform::RUBY, :version => Gem::Version.create('0.9.8')), 'a_seventh_uri']]
+    
+    requirement = Gem::Requirement.create(['< 1.1.0', '>= 1.0.0'])
+    
+    DpkgTools::Package::Gem::Setup.most_recent_spec_n_source_satisfying_requirement(requirement, specs_n_sources)[1].
+      should == 'a_fifth_uri'
+  end
+  
+  it "should be able to return a spec_n_source that satisfies a Gem::Requirement from a name" do
+    DpkgTools::Package::Gem::Setup.expects(:most_recent_spec_n_source_satisfying_requirement).
+      with(:requirement, :specs_n_sources).returns(:spec_n_source)
+    DpkgTools::Package::Gem::Setup.expects(:specs_n_sources_for_name).with('gem_name').returns(:specs_n_sources)
+    
+    DpkgTools::Package::Gem::Setup.spec_n_source_for_name_and_requirement('gem_name', :requirement).should == :spec_n_source
+  end
+  
+  it "should be able to create a new instance from a gem name and version requirement" do
+    DpkgTools::Package::Gem::Setup.expects(:spec_n_source_for_name_and_requirement).with('gem_name', :requirement).returns([:spec, 'source_uri'])
+    DpkgTools::Package::Gem::Setup.expects(:from_spec_and_source_via_cache).with(:spec, 'source_uri').returns(:instance)
+    
+    DpkgTools::Package::Gem::Setup.from_name_and_requirement('gem_name', :requirement).should == :instance
+  end
+  
+  it "should provide access to a cache of dependencies" do
+    DpkgTools::Package::Gem::Setup.dependency_cache.should be_an_instance_of(Hash)
+  end
+  
+  it "should persist the cache store between queries" do
+    DpkgTools::Package::Gem::Setup.dependency_cache.should === DpkgTools::Package::Gem::Setup.dependency_cache
+  end
+  
+  it "should be able to generate a name, version cache key from a spec" do
+    mock_spec = mock('mock Gem::Specification')
+    mock_spec.expects(:name).returns('gem_name')
+    mock_version = mock('mock Gem::Version')
+    mock_version.expects(:to_s).returns('1.0.8')
+    mock_spec.expects(:version).returns(mock_version)
+    
+    DpkgTools::Package::Gem::Setup.cache_key_from_spec(mock_spec).should == 'gem_name-1.0.8'
+  end
+end
+
+describe DpkgTools::Package::Gem::Setup, ".new" do
+  it "should raise an error without any arguments" do
+    lambda { DpkgTools::Package::Gem::Setup.new }.should raise_error
+  end
+  
+  it "should require one arguments" do
+    data = stub("DpkgTools::Package::Gem::Data", :name => 'gem_name', :version => '1.0.8')
+    DpkgTools::Package::Gem::Setup.new(data)
+  end
+end
+
+describe DpkgTools::Package::Gem::Setup, "instances" do
+  before(:each) do
+    @config = DpkgTools::Package::Config.new('gem_name', '1.0.8', :suffix => 'rubygem')
+    DpkgTools::Package::Config.expects(:new).with('gem_name', '1.0.8', :suffix => 'rubygem').returns(@config)
+    @data = stub("stub DpkgTools::Package::Gem::Data", :name => 'gem_name', :version => '1.0.8', 
+                 :full_name => 'gem_name-1.0.8', :gem_byte_string => 'gem byte string')
+    
+    @setup = DpkgTools::Package::Gem::Setup.new(@data)
+  end
+  
+  it "should provide access to its Package::Gem::Data" do
+    @setup.data.should == @data
+  end
+  
+  it "should provide access to its Package::Config" do
+    @setup.config.should == @config
+  end
+  
+  it "should provide the correct options needed to make a DpkgTools::Package::Config" do
+    @setup.config_options.should == {:suffix => 'rubygem'}
+  end
+  
+  it "should be able to write a .orig.tar.gz file with the gem in" do
+    DpkgTools::Package::Gem::Setup.expects(:write_orig_tarball).with(@config, 'gem byte string')
+    
+    @setup.write_orig_tarball
+  end
+  
+  it "should be able to write the .gem file" do
+    DpkgTools::Package::Gem::Setup.expects(:write_gem_file).with(@config, 'gem byte string')
+    
+    @setup.write_gem_file
+  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::Gem::ControlFiles.classes
+  end
+  
+  it "should be able to perform all the gem-specific steps needed to create the package structure" do
+    @setup.expects(:write_orig_tarball)
+    @setup.expects(:write_gem_file)
+    
+    @setup.prepare_package
+  end
+  
+  it "should be able to create a setup instance for a dependency which has already had its dependencies fetched" do
+    mock_dep_setup = mock('mock DpkgTools::Package::Gem::Setup')
+    mock_dep_setup.expects(:fetched_dependencies?).returns(true)
+    DpkgTools::Package::Gem::Setup.expects(:from_name_and_requirement).
+      with('gem_name', :requirement).returns(mock_dep_setup)
+    mock_dependency = mock('mock Gem::Dependency')
+    mock_dependency.expects(:name).returns('gem_name')
+    mock_dependency.expects(:version_requirements).returns(:requirement)
+    
+    @setup.fetch_dependency(mock_dependency).should == mock_dep_setup
+  end
+  
+  it "should be able to create a setup instance (and its dependencies) for a dependency" do
+    mock_dep_setup = mock('mock DpkgTools::Package::Gem::Setup')
+    mock_dep_setup.expects(:fetched_dependencies?).returns(false)
+    mock_dep_setup.expects(:fetch_dependencies).returns([:child_dep])
+    DpkgTools::Package::Gem::Setup.expects(:from_name_and_requirement).
+      with('gem_name', :requirement).returns(mock_dep_setup)
+    mock_dependency = mock('mock Gem::Dependency')
+    mock_dependency.expects(:name).returns('gem_name')
+    mock_dependency.expects(:version_requirements).returns(:requirement)
+    
+    @setup.fetch_dependency(mock_dependency).should == [mock_dep_setup, :child_dep]
+  end
+  
+  it "should be able to create setup instances for any dependencies" do
+    stub_spec = stub('Gem::Specification', :dependencies => [:dep1, :dep2])
+    @data.expects(:spec).returns(stub_spec)
+    @setup.expects(:fetch_dependency).with(:dep1).returns(:dep1_setup)
+    @setup.expects(:fetch_dependency).with(:dep2).returns(:dep2_setup)
+    @setup.fetch_dependencies.should == [:dep1_setup, :dep2_setup]
+  end
+  
+  it "should provide access to the class dependency_cache" do
+    DpkgTools::Package::Gem::Setup.expects(:dependency_cache).returns(:dependency_cache)
+    @setup.dependency_cache.should == :dependency_cache
+  end
+  
+  it "should be able to record the fact that it has fetched its dependencies" do
+    stub_spec = stub('Gem::Specification', :dependencies => [])
+    @data.expects(:spec).returns(stub_spec)
+    @setup.fetch_dependencies
+    @setup.fetched_dependencies?.should be_true
+  end
+  
+  it "should be able to record the fact that it has NOT fetched its dependencies" do
+    @setup.fetched_dependencies?.should be_false
+  end
+end