puppet 3.5.1-x86-mingw32 → 3.6.0.rc1-x86-mingw32

data/spec/unit/interface/face_collection_spec.rb

@@ -5,32 +5,44 @@ require 'tmpdir'
 require 'puppet/interface'
 
 describe Puppet::Interface::FaceCollection do
-  # To avoid cross-pollution we have to save and restore both the hash
-  # containing all the interface data, and the array used by require.  Restoring
-  # both means that we don't leak side-effects across the code. --daniel 2011-04-06
-  #
-  # Worse luck, we *also* need to flush $" of anything defining a face,
-  # because otherwise we can cross-pollute from other test files and end up
-  # with no faces loaded, but the require value set true. --daniel 2011-04-10
-  before :each do
-    @original_faces    = subject.instance_variable_get("@faces").dup
-    @original_required = $".dup
-    $".delete_if do |path| path =~ %r{/face/.*\.rb$} end
-    subject.instance_variable_get(:@faces).clear
-    subject.instance_variable_set(:@loaded, false)
-    @autoload_loaded = {}
-    Puppet::Util::Autoload.stubs(:loaded).returns(@autoload_loaded)
+
+  # To prevent conflicts with other specs that use faces, we must save and restore global state.
+  # Because there are specs that do 'describe Puppet::Face[...]', we must restore the same objects otherwise
+  # the 'subject' of the specs will differ.
+  before :all do
+    # Save FaceCollection's global state
+    faces = subject.instance_variable_get(:@faces)
+    @faces = faces.dup
+    faces.each do |k, v|
+      @faces[k] = v.dup
+    end
+    @faces_loaded = subject.instance_variable_get(:@loaded)
+
+    # Save the already required face files
+    @required = []
+    $".each do |path|
+      @required << path if path =~ /face\/.*\.rb$/
+    end
+
+    # Save Autoload's global state
+    @loaded = Puppet::Util::Autoload.instance_variable_get(:@loaded).dup
   end
 
-  after :each do
-    # Just pushing the duplicate back into place doesn't work as reliably as
-    # this method to restore the state.  Honestly, I need to make this horror
-    # go away entirely. --daniel 2012-04-28
-    faces = subject.instance_variable_get("@faces")
-    faces.clear
-    @original_faces.each {|k,v| faces[k] = v }
+  after :all do
+    # Restore global state
+    subject.instance_variable_set :@faces, @faces
+    subject.instance_variable_set :@loaded, @faces_loaded
+    $".delete_if { |path| path =~ /face\/.*\.rb$/ }
+    @required.each { |path| $".push path unless $".include? path }
+    Puppet::Util::Autoload.instance_variable_set(:@loaded, @loaded)
+  end
 
-    @original_required.each {|f| $".push f unless $".include? f }
+  before :each do
+    # Before each test, clear the faces
+    subject.instance_variable_get(:@faces).clear
+    subject.instance_variable_set(:@loaded, false)
+    Puppet::Util::Autoload.instance_variable_get(:@loaded).clear
+    $".delete_if { |path| path =~ /face\/.*\.rb$/ }
   end
 
   describe "::[]" do

data/spec/unit/module_spec.rb

@@ -19,19 +19,19 @@ describe Puppet::Module do
   end
 
   it "should have a class method that returns a named module from a given environment" do
-    env = mock 'module'
+    env = Puppet::Node::Environment.create(:myenv, [])
     env.expects(:module).with(name).returns "yep"
-    Puppet::Node::Environment.expects(:new).with("myenv").returns env
-
-    Puppet::Module.find(name, "myenv").should == "yep"
+    Puppet.override(:environments => Puppet::Environments::Static.new(env)) do
+      Puppet::Module.find(name, "myenv").should == "yep"
+    end
   end
 
   it "should return nil if asked for a named module that doesn't exist" do
-    env = mock 'module'
+    env = Puppet::Node::Environment.create(:myenv, [])
     env.expects(:module).with(name).returns nil
-    Puppet::Node::Environment.expects(:new).with("myenv").returns env
-
-    Puppet::Module.find(name, "myenv").should be_nil
+    Puppet.override(:environments => Puppet::Environments::Static.new(env)) do
+      Puppet::Module.find(name, "myenv").should be_nil
+    end
   end
 
   describe "attributes" do
@@ -97,6 +97,7 @@ describe Puppet::Module do
 
     it "should list modules that are missing" do
       metadata_file = "#{@modpath}/needy/metadata.json"
+      Puppet::FileSystem.expects(:exist?).with(metadata_file).returns true
       mod = PuppetSpec::Modules.create(
         'needy',
         @modpath,
@@ -118,6 +119,7 @@ describe Puppet::Module do
 
     it "should list modules that are missing and have invalid names" do
       metadata_file = "#{@modpath}/needy/metadata.json"
+      Puppet::FileSystem.expects(:exist?).with(metadata_file).returns true
       mod = PuppetSpec::Modules.create(
         'needy',
         @modpath,
@@ -140,6 +142,10 @@ describe Puppet::Module do
     it "should list modules with unmet version requirement" do
       env = Puppet::Node::Environment.create(:testing, [@modpath])
 
+      ['test_gte_req', 'test_specific_req', 'foobar'].each do |mod_name|
+        metadata_file = "#{@modpath}/#{mod_name}/metadata.json"
+        Puppet::FileSystem.stubs(:exist?).with(metadata_file).returns true
+      end
       mod = PuppetSpec::Modules.create(
         'test_gte_req',
         @modpath,
@@ -217,6 +223,8 @@ describe Puppet::Module do
     it "should consider a dependency without a semantic version to be unmet" do
       env = Puppet::Node::Environment.create(:testing, [@modpath])
 
+      metadata_file = "#{@modpath}/foobar/metadata.json"
+      Puppet::FileSystem.expects(:exist?).with(metadata_file).times(3).returns true
       mod = PuppetSpec::Modules.create(
         'foobar',
         @modpath,
@@ -261,6 +269,10 @@ describe Puppet::Module do
     it "should only list unmet dependencies" do
       env = Puppet::Node::Environment.create(:testing, [@modpath])
 
+      [name, 'satisfied'].each do |mod_name|
+        metadata_file = "#{@modpath}/#{mod_name}/metadata.json"
+        Puppet::FileSystem.expects(:exist?).with(metadata_file).twice.returns true
+      end
       mod = PuppetSpec::Modules.create(
         name,
         @modpath,

data/spec/unit/module_tool/applications/builder_spec.rb

@@ -6,15 +6,42 @@ describe Puppet::ModuleTool::Applications::Builder do
   include PuppetSpec::Files
 
   let(:path)         { tmpdir("working_dir") }
-  let(:module_name)  { 'myusername-mytarball' }
+  let(:module_name)  { 'mymodule-mytarball' }
   let(:version)      { '0.0.1' }
   let(:release_name) { "#{module_name}-#{version}" }
   let(:tarball)      { File.join(path, 'pkg', release_name) + ".tar.gz" }
   let(:builder)      { Puppet::ModuleTool::Applications::Builder.new(path) }
 
-  before :each do
-    File.open(File.join(path, 'Modulefile'), 'w') do |f|
-      f.write(<<EOM)
+  context 'with metadata.json' do
+    before :each do
+      File.open(File.join(path, 'metadata.json'), 'w') do |f|
+        f.puts({
+          "name" => "#{module_name}",
+          "version" => "#{version}",
+          "source" => "http://github.com/testing/#{module_name}",
+          "author" => "testing",
+          "license" => "Apache License Version 2.0",
+          "summary" => "Puppet testing module",
+          "description" => "This module can be used for basic testing",
+          "project_page" => "http://github.com/testing/#{module_name}"
+        }.to_json)
+      end
+    end
+
+    it "packages the module in a tarball named after the module" do
+      tarrer = mock('tarrer')
+      Puppet::ModuleTool::Tar.expects(:instance).returns(tarrer)
+      Dir.expects(:chdir).with(File.join(path, 'pkg')).yields
+      tarrer.expects(:pack).with(release_name, tarball)
+
+      builder.run
+    end
+  end
+
+  context 'with Modulefile' do
+    before :each do
+      File.open(File.join(path, 'Modulefile'), 'w') do |f|
+        f.write <<-MODULEFILE
 name    '#{module_name}'
 version '#{version}'
 source 'http://github.com/testing/#{module_name}'
@@ -23,16 +50,17 @@ license 'Apache License Version 2.0'
 summary 'Puppet testing module'
 description 'This module can be used for basic testing'
 project_page 'http://github.com/testing/#{module_name}'
-EOM
+MODULEFILE
+      end
     end
-  end
 
-  it "should attempt to create a module relative to the pkg directory" do
-    tarrer = mock('tarrer')
-    Puppet::ModuleTool::Tar.expects(:instance).with(module_name).returns(tarrer)
-    Dir.expects(:chdir).with(File.join(path, 'pkg')).yields
-    tarrer.expects(:pack).with(release_name, tarball)
+    it "packages the module in a tarball named after the module" do
+      tarrer = mock('tarrer')
+      Puppet::ModuleTool::Tar.expects(:instance).returns(tarrer)
+      Dir.expects(:chdir).with(File.join(path, 'pkg')).yields
+      tarrer.expects(:pack).with(release_name, tarball)
 
-    builder.run
+      builder.run
+    end
   end
 end

data/spec/unit/module_tool/applications/checksummer_spec.rb

@@ -1,134 +1,115 @@
 require 'spec_helper'
 require 'puppet/module_tool/applications'
+require 'puppet_spec/files'
+require 'pathname'
 
 describe Puppet::ModuleTool::Applications::Checksummer do
-  subject {
-    Puppet::ModuleTool::Applications::Checksummer.new(module_install_path)
-  }
-
-  let(:module_install_path) { 'foo' }
-  let(:module_metadata_file) { 'metadata.json' }
-
-  let(:module_install_pathname) {
-    module_install_pathname = mock()
-    Pathname.expects(:new).with(module_install_path).\
-      returns(module_install_pathname)
-    module_install_pathname
-  }
-
-  def stub_module_file_pathname(relative_path, present)
-    module_file_pathname = mock() do
-      expects(:exist?).with().returns(present)
-    end
+  let(:tmpdir) do
+    Pathname.new(PuppetSpec::Files.tmpdir('checksummer'))
+  end
+
+  let(:checksums) { Puppet::ModuleTool::Checksums.new(tmpdir).data }
 
-    module_install_pathname.expects(:+).with(relative_path).\
-      returns(module_file_pathname)
+  subject do
+    described_class.run(tmpdir)
+  end
 
-    module_file_pathname
+  before do
+    File.open(tmpdir + 'README', 'w') { |f| f.puts "This is a README!" }
+    File.open(tmpdir + 'CHANGES', 'w') { |f| f.puts "This is a changelog!" }
+    File.open(tmpdir + 'DELETEME', 'w') { |f| f.puts "I've got a really good feeling about this!" }
+    Dir.mkdir(tmpdir + 'pkg')
+    File.open(tmpdir + 'pkg' + 'build-artifact', 'w') { |f| f.puts "I'm unimportant!" }
+    File.open(tmpdir + 'metadata.json', 'w') { |f| f.puts '{"name": "package-name", "version": "1.0.0"}' }
+    File.open(tmpdir + 'checksums.json', 'w') { |f| f.puts '{}' }
   end
 
-  context %q{when metadata.json doesn't exist in the specified module install path} do
-    before(:each) do
-      stub_module_file_pathname(module_metadata_file, false)
-      subject.expects(:metadata_file).with().\
-        returns(module_install_pathname + module_metadata_file)
+  context 'with checksums.json' do
+    before do
+      File.open(tmpdir + 'checksums.json', 'w') { |f| f.puts checksums.to_json }
+      File.open(tmpdir + 'CHANGES', 'w') { |f| f.puts "This is a changed log!" }
+      File.open(tmpdir + 'pkg' + 'build-artifact', 'w') { |f| f.puts "I'm still unimportant!" }
+      (tmpdir + 'DELETEME').unlink
     end
 
-    it 'raises an ArgumentError exception' do
-      lambda {
-        subject.run
-      }.should raise_error(ArgumentError, 'No metadata.json found.')
+    it 'reports changed files' do
+      expect(subject).to include 'CHANGES'
     end
-  end
 
-  context 'when metadata.json exists in the specified module install path' do
-    module_files = {
-      'README'     => '1',
-      'CHANGELOG'  => '2',
-      'Modulefile' => '3',
-    }
-    let(:module_files) { module_files }
-    let(:checksum_computer) {
-      checksum_computer = mock()
-      Puppet::ModuleTool::Checksums.\
-        expects(:new).with(module_install_pathname).\
-        returns(checksum_computer)
-      checksum_computer
-    }
-    # all possible combinations (of all lengths) of the module files
-    module_files_combination =
-      1.upto(module_files.size()).inject([]) { |module_files_combination, n|
-        module_files.keys.combination(n) { |combination|
-          module_files_combination << combination
-        }
-        module_files_combination
-      }
-
-    def stub_module_file_pathname_with_checksum(relative_path, checksum)
-      module_file_pathname =
-        stub_module_file_pathname(relative_path, present = !checksum.nil?)
-      # mock the call of Puppet::ModuleTool::Checksums#checksum
-      expectation = checksum_computer.\
-        expects(:checksum).with(module_file_pathname)
-      if present
-        # return the cheksum directly
-        expectation.returns(checksum)
-      else
-        # if the file is not present, then the method should not be called
-        expectation.times(0)
-      end
-      module_file_pathname
+    it 'reports removed files' do
+      expect(subject).to include 'DELETEME'
     end
 
-    def stub_module_files(overrides = {})
-      overrides.reject! { |key, value|
-        !module_files.include?(key)
-      }
-      module_files.merge(overrides).each { |relative_path, checksum|
-        stub_module_file_pathname_with_checksum(relative_path, checksum)
-      }
+    it 'does not report unchanged files' do
+      expect(subject).to_not include 'README'
     end
 
-    before(:each) do
-      stub_module_file_pathname(module_metadata_file, true)
-      subject.expects(:metadata_file).with().\
-        returns(module_install_pathname + module_metadata_file)
-      subject.expects(:metadata).with().\
-        returns({ 'checksums' => module_files })
+    it 'does not report build artifacts' do
+      expect(subject).to_not include 'pkg/build-artifact'
     end
 
-    module_files_combination.each do |removed_files|
-      it "reports removed file(s) #{removed_files.inspect}" do
-        stub_module_files(
-          removed_files.inject({}) { |overrides, removed_file|
-            overrides[removed_file] = nil
-            overrides
-          }
-        )
+    it 'does not report checksums.json' do
+      expect(subject).to_not include 'checksums.json'
+    end
+  end
+
+  context 'without checksums.json' do
+    context 'but with metadata.json containing checksums' do
+      before do
+        (tmpdir + 'checksums.json').unlink
+        File.open(tmpdir + 'metadata.json', 'w') { |f| f.puts "{\"checksums\":#{checksums.to_json}}" }
+        File.open(tmpdir + 'CHANGES', 'w') { |f| f.puts "This is a changed log!" }
+        File.open(tmpdir + 'pkg' + 'build-artifact', 'w') { |f| f.puts "I'm still unimportant!" }
+        (tmpdir + 'DELETEME').unlink
+      end
+
+      it 'reports changed files' do
+        expect(subject).to include 'CHANGES'
+      end
 
-        subject.run.should == removed_files
+      it 'reports removed files' do
+        expect(subject).to include 'DELETEME'
+      end
+
+      it 'does not report unchanged files' do
+        expect(subject).to_not include 'README'
+      end
+
+      it 'does not report build artifacts' do
+        expect(subject).to_not include 'pkg/build-artifact'
+      end
+
+      it 'does not report checksums.json' do
+        expect(subject).to_not include 'checksums.json'
       end
     end
 
-    module_files_combination.each do |modified_files|
-      it "reports modified file(s) #{modified_files.inspect}" do
-        stub_module_files(
-          modified_files.inject({}) { |overrides, modified_file|
-            modified_checksum = module_files[modified_file].to_s.succ
-            modified_checksum = ' ' if modified_checksum.empty?
-            overrides[modified_file] = modified_checksum
-            overrides
-          }
-        )
-
-        subject.run.should == modified_files
+    context 'and with metadata.json that does not contain checksums' do
+      before do
+        (tmpdir + 'checksums.json').unlink
+        File.open(tmpdir + 'CHANGES', 'w') { |f| f.puts "This is a changed log!" }
+        File.open(tmpdir + 'pkg' + 'build-artifact', 'w') { |f| f.puts "I'm still unimportant!" }
+        (tmpdir + 'DELETEME').unlink
+      end
+
+      it 'fails' do
+        expect { subject }.to raise_error(ArgumentError, 'No file containing checksums found.')
       end
     end
 
-    it 'does not report unmodified files' do
-      stub_module_files()
+    context 'and without metadata.json' do
+      before do
+        (tmpdir + 'checksums.json').unlink
+        (tmpdir + 'metadata.json').unlink
 
-      subject.run.should == []
+        File.open(tmpdir + 'CHANGES', 'w') { |f| f.puts "This is a changed log!" }
+        File.open(tmpdir + 'pkg' + 'build-artifact', 'w') { |f| f.puts "I'm still unimportant!" }
+        (tmpdir + 'DELETEME').unlink
+      end
+
+      it 'fails' do
+        expect { subject }.to raise_error(ArgumentError, 'No file containing checksums found.')
+      end
     end
   end
 end

data/spec/unit/module_tool/applications/installer_spec.rb

@@ -1,331 +1,363 @@
 require 'spec_helper'
 require 'puppet/module_tool/applications'
-require 'puppet_spec/modules'
+require 'puppet_spec/module_tool/shared_functions'
+require 'puppet_spec/module_tool/stub_source'
 require 'semver'
 
 describe Puppet::ModuleTool::Applications::Installer do
+  include PuppetSpec::ModuleTool::SharedFunctions
   include PuppetSpec::Files
+  include PuppetSpec::Fixtures
 
-  let(:unpacker)        { stub(:run) }
-  let(:installer_class) { Puppet::ModuleTool::Applications::Installer }
-  let(:modpath1) do
-    path = File.join(tmpdir("installer"), "modpath1")
-    FileUtils.mkdir_p(path)
-    path
-  end
-  let(:stdlib_pkg) do
-    mod = File.join(modpath1, "pmtacceptance-stdlib-0.0.1.tar.gz")
-    FileUtils.touch(mod)
-    mod
-  end
-  let(:env)             { Puppet::Node::Environment.create(:env, [modpath1]) }
-  let(:options)         do
-    {
-      :target_dir => modpath1,
-      :environment_instance => env,
-    }
+  before do
+    FileUtils.mkdir_p(primary_dir)
+    FileUtils.mkdir_p(secondary_dir)
   end
 
-  let(:forge) do
-    forge = mock("Puppet::Forge")
+  let(:vardir)        { tmpdir('installer') }
+  let(:primary_dir)   { File.join(vardir, "primary") }
+  let(:secondary_dir) { File.join(vardir, "secondary") }
+  let(:remote_source) { PuppetSpec::ModuleTool::StubSource.new }
 
-    forge.stubs(:remote_dependency_info).returns(remote_dependency_info)
-    forge.stubs(:uri).returns('forge-dev.puppetlabs.com')
-    remote_dependency_info.each_key do |mod|
-      remote_dependency_info[mod].each do |release|
-        forge.stubs(:retrieve).with(release['file']).returns("/fake_cache#{release['file']}")
-      end
+  let(:install_dir) do
+    mock("Puppet::ModuleTool::InstallDirectory").tap do |dir|
+      dir.stubs(:prepare)
+      dir.stubs(:target).returns(primary_dir)
     end
+  end
 
-    forge
+  before do
+    Semantic::Dependency.clear_sources
+    installer = Puppet::ModuleTool::Applications::Installer.any_instance
+    installer.stubs(:module_repository).returns(remote_source)
   end
 
-  let(:install_dir) do
-    install_dir = mock("Puppet::ModuleTool::InstallDirectory")
-    install_dir.stubs(:prepare)
-    install_dir
+  def installer(modname, target_dir, options)
+    Puppet::ModuleTool.set_option_defaults(options)
+    Puppet::ModuleTool::Applications::Installer.new(modname, target_dir, options)
   end
 
-  let(:remote_dependency_info) do
-    {
-      "pmtacceptance/apache" => [
-        { "dependencies" => [],
-          "version"      => "1.0.0-alpha",
-          "file"         => "/pmtacceptance-apache-1.0.0-alpha.tar.gz" },
-        { "dependencies" => [],
-          "version"      => "1.0.0-beta",
-          "file"         => "/pmtacceptance-apache-1.0.0-beta.tar.gz" },
-        { "dependencies" => [],
-          "version"      => "1.0.0-rc1",
-          "file"         => "/pmtacceptance-apache-1.0.0-rc1.tar.gz" },
-      ],
-      "pmtacceptance/stdlib" => [
-        { "dependencies" => [],
-          "version"      => "0.0.1",
-          "file"         => "/pmtacceptance-stdlib-0.0.1.tar.gz" },
-        { "dependencies" => [],
-          "version"      => "0.0.2",
-          "file"         => "/pmtacceptance-stdlib-0.0.2.tar.gz" },
-        { "dependencies" => [],
-          "version"      => "1.0.0-pre",
-          "file"         => "/pmtacceptance-stdlib-1.0.0-pre.tar.gz" },
-        { "dependencies" => [],
-          "version"      => "1.0.0",
-          "file"         => "/pmtacceptance-stdlib-1.0.0.tar.gz" },
-        { "dependencies" => [],
-          "version"      => "1.5.0-pre",
-          "file"         => "/pmtacceptance-stdlib-1.5.0-pre.tar.gz" },
-      ],
-      "pmtacceptance/java" => [
-        { "dependencies" => [["pmtacceptance/stdlib", ">= 0.0.1"]],
-          "version"      => "1.7.0",
-          "file"         => "/pmtacceptance-java-1.7.0.tar.gz" },
-        { "dependencies" => [["pmtacceptance/stdlib", "1.0.0"]],
-          "version"      => "1.7.1",
-          "file"         => "/pmtacceptance-java-1.7.1.tar.gz" }
-      ],
-      "pmtacceptance/apollo" => [
-        { "dependencies" => [
-            ["pmtacceptance/java", "1.7.1"],
-            ["pmtacceptance/stdlib", "0.0.1"]
-          ],
-          "version" => "0.0.1",
-          "file"    => "/pmtacceptance-apollo-0.0.1.tar.gz" },
-        { "dependencies" => [
-            ["pmtacceptance/java", ">= 1.7.0"],
-            ["pmtacceptance/stdlib", ">= 1.0.0"]
-          ],
-          "version" => "0.0.2",
-          "file"    => "/pmtacceptance-apollo-0.0.2.tar.gz" }
-      ]
-    }
+  let(:environment) do
+    Puppet.lookup(:current_environment).override_with(
+      :vardir     => vardir,
+      :modulepath => [ primary_dir, secondary_dir ]
+    )
   end
 
-  describe "the behavior of .is_module_package?" do
-    it "should return true when file is a module package" do
-      installer = installer_class.new("foo", forge, install_dir, options)
-      installer.send(:is_module_package?, stdlib_pkg).should be_true
-    end
+  context '#run' do
+    let(:module) { 'pmtacceptance-stdlib' }
 
-    it "should return false when file is not a module package" do
-      installer = installer_class.new("foo", forge, install_dir, options)
-      installer.send(:is_module_package?, "pmtacceptance-apollo-0.0.2.tar").
-        should be_false
+    def options
+      { :environment => environment }
     end
-  end
 
-  context "when the source is a repository" do
-    it "should require a valid name" do
-      lambda { installer_class.run('puppet', install_dir, params) }.should
-        raise_error(ArgumentError, "Could not install module with invalid name: puppet")
-    end
+    let(:application) { installer(self.module, install_dir, options) }
+    subject { application.run }
 
-    it "should install the current stable version of the requested module" do
-      Puppet::ModuleTool::Applications::Unpacker.expects(:new).
-        with('/fake_cache/pmtacceptance-stdlib-1.0.0.tar.gz', options).
-        returns(unpacker)
-      results = installer_class.run('pmtacceptance-stdlib', forge, install_dir, options)
-      results[:installed_modules].length == 1
-      results[:installed_modules][0][:module].should == "pmtacceptance-stdlib"
-      results[:installed_modules][0][:version][:vstring].should == "1.0.0"
+    it 'installs the specified module' do
+      subject.should include :result => :success
+      graph_should_include 'pmtacceptance-stdlib', nil => v('4.1.0')
     end
 
-    it "should install the most recent version of requested module in the absence of a stable version" do
-      Puppet::ModuleTool::Applications::Unpacker.expects(:new).
-        with('/fake_cache/pmtacceptance-apache-1.0.0-rc1.tar.gz', options).
-        returns(unpacker)
-      results = installer_class.run('pmtacceptance-apache', forge, install_dir, options)
-      results[:installed_modules].length == 1
-      results[:installed_modules][0][:module].should == "pmtacceptance-apache"
-      results[:installed_modules][0][:version][:vstring].should == "1.0.0-rc1"
-    end
+    context 'with a tarball file' do
+      let(:module) { fixtures('stdlib.tgz') }
 
-    it "should install the most recent stable version of requested module for the requested version range" do
-      Puppet::ModuleTool::Applications::Unpacker.expects(:new).
-        with('/fake_cache/pmtacceptance-stdlib-1.0.0.tar.gz', options.merge(:version => '1.x')).
-        returns(unpacker)
-      results = installer_class.run('pmtacceptance-stdlib', forge, install_dir, options.merge(:version => '1.x'))
-      results[:installed_modules].length == 1
-      results[:installed_modules][0][:module].should == "pmtacceptance-stdlib"
-      results[:installed_modules][0][:version][:vstring].should == "1.0.0"
-    end
+      it 'installs the specified tarball' do
+        subject.should include :result => :success
+        graph_should_include 'puppetlabs-stdlib', nil => v('3.2.0')
+      end
 
-    it "should install the most recent version of requested module for the requested version range in the absence of a stable version" do
-      Puppet::ModuleTool::Applications::Unpacker.expects(:new).
-      with('/fake_cache/pmtacceptance-stdlib-1.5.0-pre.tar.gz', options.merge(:version => '1.5.0-pre')).
-        returns(unpacker)
-      results = installer_class.run('pmtacceptance-stdlib', forge, install_dir, options.merge(:version => '1.5.0-pre'))
-      results[:installed_modules].length == 1
-      results[:installed_modules][0][:module].should == "pmtacceptance-stdlib"
-      results[:installed_modules][0][:version][:vstring].should == "1.5.0-pre"
-    end
+      context 'with --ignore-dependencies' do
+        def options
+          super.merge(:ignore_dependencies => true)
+        end
 
-    context "should check the target directory" do
-      let(:installer) do
-        installer_class.new('pmtacceptance-stdlib', forge, install_dir, options)
+        it 'installs the specified tarball' do
+          remote_source.expects(:fetch).never
+          subject.should include :result => :success
+          graph_should_include 'puppetlabs-stdlib', nil => v('3.2.0')
+        end
       end
 
-      def expect_normal_unpacker
-        Puppet::ModuleTool::Applications::Unpacker.expects(:new).
-          with('/fake_cache/pmtacceptance-stdlib-1.0.0.tar.gz', options).
-          returns(unpacker)
+      context 'with dependencies' do
+        let(:module) { fixtures('java.tgz') }
+
+        it 'installs the specified tarball' do
+          subject.should include :result => :success
+          graph_should_include 'puppetlabs-java', nil => v('1.0.0')
+          graph_should_include 'puppetlabs-stdlib', nil => v('4.1.0')
+        end
+
+        context 'with --ignore-dependencies' do
+          def options
+            super.merge(:ignore_dependencies => true)
+          end
+
+          it 'installs the specified tarball without dependencies' do
+            remote_source.expects(:fetch).never
+            subject.should include :result => :success
+            graph_should_include 'puppetlabs-java', nil => v('1.0.0')
+            graph_should_include 'puppetlabs-stdlib', nil
+          end
+        end
       end
+    end
+
+    context 'with dependencies' do
+      let(:module) { 'pmtacceptance-apache' }
 
-      def expect_normal_results
-        results
+      it 'installs the specified module and its dependencies' do
+        subject.should include :result => :success
+        graph_should_include 'pmtacceptance-apache', nil => v('0.10.0')
+        graph_should_include 'pmtacceptance-stdlib', nil => v('4.1.0')
       end
 
-      it "(#15202) prepares the install directory" do
-        expect_normal_unpacker
-        install_dir.expects(:prepare).with("pmtacceptance-stdlib", "latest")
+      context 'and using --ignore_dependencies' do
+        def options
+          super.merge(:ignore_dependencies => true)
+        end
+
+        it 'installs only the specified module' do
+          subject.should include :result => :success
+          graph_should_include 'pmtacceptance-apache', nil => v('0.10.0')
+          graph_should_include 'pmtacceptance-stdlib', nil
+        end
+      end
+
+      context 'that are already installed' do
+        context 'and satisfied' do
+          before { preinstall('pmtacceptance-stdlib', '4.1.0') }
+
+          it 'installs only the specified module' do
+            subject.should include :result => :success
+            graph_should_include 'pmtacceptance-apache', nil => v('0.10.0')
+            graph_should_include 'pmtacceptance-stdlib', :path => primary_dir
+          end
+
+          context '(outdated but suitable version)' do
+            before { preinstall('pmtacceptance-stdlib', '2.4.0') }
+
+            it 'installs only the specified module' do
+              subject.should include :result => :success
+              graph_should_include 'pmtacceptance-apache', nil => v('0.10.0')
+              graph_should_include 'pmtacceptance-stdlib', v('2.4.0') => v('2.4.0'), :path => primary_dir
+            end
+          end
+
+          context '(outdated and unsuitable version)' do
+            before { preinstall('pmtacceptance-stdlib', '1.0.0') }
+
+            it 'installs a version that is compatible with the installed dependencies' do
+              subject.should include :result => :success
+              graph_should_include 'pmtacceptance-apache', nil => v('0.0.4')
+              graph_should_include 'pmtacceptance-stdlib', nil
+            end
+          end
+        end
 
-        results = installer.run
+        context 'but not satisfied' do
+          let(:module) { 'pmtacceptance-keystone' }
 
-        results[:installed_modules].length.should eq 1
-        results[:installed_modules][0][:module].should == "pmtacceptance-stdlib"
-        results[:installed_modules][0][:version][:vstring].should == "1.0.0"
+          def options
+            super.merge(:version => '2.0.0')
+          end
+
+          before { preinstall('pmtacceptance-mysql', '2.1.0') }
+
+          it 'installs only the specified module' do
+            subject.should include :result => :success
+            graph_should_include 'pmtacceptance-keystone', nil => v('2.0.0')
+            graph_should_include 'pmtacceptance-mysql', v('2.1.0') => v('2.1.0')
+            graph_should_include 'pmtacceptance-stdlib', nil
+          end
+        end
       end
 
-      it "(#15202) reports an error when the install directory cannot be prepared" do
-        install_dir.expects(:prepare).with("pmtacceptance-stdlib", "latest").
-          raises(Puppet::ModuleTool::Errors::PermissionDeniedCreateInstallDirectoryError.new("original", :module => "pmtacceptance-stdlib"))
+      context 'that are already installed in other modulepath directories' do
+        before { preinstall('pmtacceptance-stdlib', '1.0.0', :into => secondary_dir) }
+        let(:module) { 'pmtacceptance-apache' }
+
+        context 'without dependency updates' do
+          it 'installs the module only' do
+            subject.should include :result => :success
+            graph_should_include 'pmtacceptance-apache', nil => v('0.0.4')
+            graph_should_include 'pmtacceptance-stdlib', nil
+          end
+        end
 
-        results = installer.run
+        context 'with dependency updates' do
+          before { preinstall('pmtacceptance-stdlib', '2.0.0', :into => secondary_dir) }
 
-        results[:result].should == :failure
-        results[:error][:oneline].should =~ /Permission is denied/
+          it 'installs the module and upgrades dependencies in-place' do
+            subject.should include :result => :success
+            graph_should_include 'pmtacceptance-apache', nil => v('0.10.0')
+            graph_should_include 'pmtacceptance-stdlib', v('2.0.0') => v('2.6.0'), :path => secondary_dir
+          end
+        end
       end
     end
 
-    context "when the requested module has dependencies" do
-      it "should install dependencies" do
-        Puppet::ModuleTool::Applications::Unpacker.expects(:new).
-          with('/fake_cache/pmtacceptance-stdlib-1.0.0.tar.gz', options).
-          returns(unpacker)
-        Puppet::ModuleTool::Applications::Unpacker.expects(:new).
-          with('/fake_cache/pmtacceptance-apollo-0.0.2.tar.gz', options).
-          returns(unpacker)
-        Puppet::ModuleTool::Applications::Unpacker.expects(:new).
-          with('/fake_cache/pmtacceptance-java-1.7.1.tar.gz', options).
-          returns(unpacker)
-
-        results = installer_class.run('pmtacceptance-apollo', forge, install_dir, options)
-        installed_dependencies = results[:installed_modules][0][:dependencies]
-
-        dependencies = installed_dependencies.inject({}) do |result, dep|
-          result[dep[:module]] = dep[:version][:vstring]
-          result
+    context 'with a specified' do
+
+      context 'version' do
+        def options
+          super.merge(:version => '3.0.0')
         end
 
-        dependencies.length.should == 2
-        dependencies['pmtacceptance-java'].should   == '1.7.1'
-        dependencies['pmtacceptance-stdlib'].should == '1.0.0'
+        it 'installs the specified release (or a prerelease thereof)' do
+          subject.should include :result => :success
+          graph_should_include 'pmtacceptance-stdlib', nil => v('3.0.0')
+        end
       end
 
-      it "should install requested module if the '--force' flag is used" do
-        options.merge!(:force => true)
-        Puppet::ModuleTool::Applications::Unpacker.expects(:new).
-          with('/fake_cache/pmtacceptance-apollo-0.0.2.tar.gz', options).
-          returns(unpacker)
-        results = installer_class.run('pmtacceptance-apollo', forge, install_dir, options)
-        results[:installed_modules][0][:module].should == "pmtacceptance-apollo"
+      context 'version range' do
+        def options
+          super.merge(:version => '3.x')
+        end
+
+        it 'installs the greatest available version matching that range' do
+          subject.should include :result => :success
+          graph_should_include 'pmtacceptance-stdlib', nil => v('3.2.0')
+        end
       end
+    end
+
+    context 'when depended upon' do
+      before { preinstall('pmtacceptance-keystone', '2.1.0') }
+      let(:module)  { 'pmtacceptance-mysql' }
 
-      it "should not install dependencies if the '--force' flag is used" do
-        options.merge!(:force => true)
-        Puppet::ModuleTool::Applications::Unpacker.expects(:new).
-          with('/fake_cache/pmtacceptance-apollo-0.0.2.tar.gz', options).
-          returns(unpacker)
-        results = installer_class.run('pmtacceptance-apollo', forge, install_dir, options)
-        dependencies = results[:installed_modules][0][:dependencies]
-        dependencies.should == []
+      it 'installs the greatest available version meeting the dependency constraints' do
+        subject.should include :result => :success
+        graph_should_include 'pmtacceptance-mysql', nil => v('0.9.0')
       end
 
-      it "should not install dependencies if the '--ignore-dependencies' flag is used" do
-        options.merge!(:ignore_dependencies => true)
-        Puppet::ModuleTool::Applications::Unpacker.expects(:new).
-          with('/fake_cache/pmtacceptance-apollo-0.0.2.tar.gz', options).
-          returns(unpacker)
-        results = installer_class.run('pmtacceptance-apollo', forge, install_dir, options)
-        dependencies = results[:installed_modules][0][:dependencies]
-        dependencies.should == []
+      context 'with a --version that can satisfy' do
+        def options
+          super.merge(:version => '0.8.0')
+        end
+
+        it 'installs the greatest available version satisfying both constraints' do
+          subject.should include :result => :success
+          graph_should_include 'pmtacceptance-mysql', nil => v('0.8.0')
+        end
       end
 
-      it "should set an error if dependencies can't be resolved" do
-        options.merge!(:version => '0.0.1')
-        oneline = "'pmtacceptance-apollo' (v0.0.1) requested; Invalid dependency cycle"
-        multiline = <<-MSG.strip
-Could not install module 'pmtacceptance-apollo' (v0.0.1)
-  No version of 'pmtacceptance-stdlib' will satisfy dependencies
-    You specified 'pmtacceptance-apollo' (v0.0.1),
-    which depends on 'pmtacceptance-java' (v1.7.1),
-    which depends on 'pmtacceptance-stdlib' (v1.0.0)
-    Use `puppet module install --force` to install this module anyway
-MSG
-
-        results = installer_class.run('pmtacceptance-apollo', forge, install_dir, options)
-        results[:result].should == :failure
-        results[:error][:oneline].should == oneline
-        results[:error][:multiline].should == multiline
+      context 'with a --version that cannot satisfy' do
+        def options
+          super.merge(:version => '> 1.0.0')
+        end
+
+        it 'fails to install, since there is no version that can satisfy both constraints' do
+          subject.should include :result => :failure
+        end
+
+        context 'with --ignore-dependencies' do
+          def options
+            super.merge(:ignore_dependencies => true)
+          end
+
+          it 'fails to install, since ignore_dependencies should still respect dependencies from installed modules' do
+            subject.should include :result => :failure
+          end
+        end
+
+        context 'with --force' do
+          def options
+            super.merge(:force => true)
+          end
+
+          it 'installs the greatest available version, ignoring dependencies' do
+            subject.should include :result => :success
+            graph_should_include 'pmtacceptance-mysql', nil => v('2.1.0')
+          end
+        end
       end
+    end
 
-      it "resolves conflicts for each dependency only once" do
-        Puppet::Log.level = :debug
+    context 'when already installed' do
+      before { preinstall('pmtacceptance-stdlib', '1.0.0') }
 
-        installed_modules = [
-          Puppet::Module.new('ntp', File.join(modpath1, 'ntp'), env.name),
-          Puppet::Module.new('mysql', File.join(modpath1, 'mysql'), env.name),
-          Puppet::Module.new('apache', File.join(modpath1, 'apache'), env.name)
-        ]
+      context 'but matching the requested version' do
+        it 'does nothing, since the installed version satisfies' do
+          subject.should include :result => :noop
+        end
 
-        env.stubs(:modules_by_path).returns({modpath1 => installed_modules})
+        context 'with --force' do
+          def options
+            super.merge(:force => true)
+          end
 
-        Puppet::ModuleTool::Applications::Unpacker.expects(:new).
-          with('/fake_cache/pmtacceptance-apollo-0.0.2.tar.gz', options).
-          returns(unpacker)
-        Puppet::ModuleTool::Applications::Unpacker.expects(:new).
-          with('/fake_cache/pmtacceptance-java-1.7.1.tar.gz', options).
-          returns(unpacker)
-        Puppet::ModuleTool::Applications::Unpacker.expects(:new).
-          with('/fake_cache/pmtacceptance-stdlib-1.0.0.tar.gz', options).
-          returns(unpacker)
+          it 'does reinstall the module' do
+            subject.should include :result => :success
+            graph_should_include 'pmtacceptance-stdlib', v('1.0.0') => v('4.1.0')
+          end
+        end
 
-        installer_class.run('pmtacceptance-apollo', forge, install_dir, options)
+        context 'with local changes' do
+          before do
+            release = application.send(:installed_modules)['pmtacceptance-stdlib']
+            mark_changed(release.mod.path)
+          end
+
+          it 'does nothing, since local changes do not affect that' do
+            subject.should include :result => :noop
+          end
+
+          context 'with --force' do
+            def options
+              super.merge(:force => true)
+            end
+
+            it 'does reinstall the module, since --force ignores local changes' do
+              subject.should include :result => :success
+              graph_should_include 'pmtacceptance-stdlib', v('1.0.0') => v('4.1.0')
+            end
+          end
+        end
+      end
 
-        modules = @logs.map do |log|
-          data = log.message.match(/Resolving conflicts for (.*)/)
-          data ? data[1] : nil
-        end.compact
+      context 'but not matching the requested version' do
+        def options
+          super.merge(:version => '2.x')
+        end
 
-        expect(modules).to eq(["pmtacceptance-apollo", "pmtacceptance-java,pmtacceptance-stdlib"])
+        it 'fails to install the module, since it is already installed' do
+          subject.should include :result => :failure
+          subject[:error].should include :oneline => "'pmtacceptance-stdlib' (v2.x) requested; 'pmtacceptance-stdlib' (v1.0.0) already installed"
+        end
+
+        context 'with --force' do
+          def options
+            super.merge(:force => true)
+          end
+
+          it 'installs the greatest version matching the new version range' do
+            subject.should include :result => :success
+            graph_should_include 'pmtacceptance-stdlib', v('1.0.0') => v('2.6.0')
+          end
+        end
       end
     end
 
-    context "when there are modules installed" do
-      it "should use local version when already exists and satisfies constraints"
-      it "should reinstall the local version if force is used"
-      it "should upgrade local version when necessary to satisfy constraints"
-      it "should error when a local version can't be upgraded to satisfy constraints"
-    end
+    context 'when a module with the same name is already installed' do
+      let(:module) { 'pmtacceptance-stdlib' }
+      before { preinstall('puppetlabs-stdlib', '4.1.0') }
 
-    context "when a local module needs upgrading to satisfy constraints but has changes" do
-      it "should error"
-      it "should warn and continue if force is used"
-    end
+      it 'fails to install, since two modules with the same name cannot be installed simultaneously' do
+        subject.should include :result => :failure
+      end
 
-    it "should error when a local version of a dependency has no version metadata"
-    it "should error when a local version of a dependency has a non-semver version"
-    it "should error when a local version of a dependency has a different forge name"
-    it "should error when a local version of a dependency has no metadata"
-  end
+      context 'using --force' do
+        def options
+          super.merge(:force => true)
+        end
 
-  context "when the source is a filesystem" do
-    before do
-      @sourcedir = tmpdir('sourcedir')
+        it 'overwrites the existing module with the greatest version of the requested module' do
+          subject.should include :result => :success
+          graph_should_include 'pmtacceptance-stdlib', nil => v('4.1.0')
+        end
+      end
     end
 
-    it "should error if it can't parse the name"
-
-    it "should try to get_release_package_from_filesystem if it has a valid name"
   end
 end