puppet 2.7.11 → 2.7.12

data/spec/unit/forge/repository_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+require 'net/http'
+require 'puppet/forge/repository'
+require 'puppet/forge/cache'
+
+describe Puppet::Forge::Repository do
+  describe 'instances' do
+
+    let(:repository) { Puppet::Forge::Repository.new('http://fake.com') }
+
+    describe '#make_http_request' do
+      before do
+        # Do a mock of the Proxy call so we can do proper expects for
+        # Net::HTTP
+        Net::HTTP.expects(:Proxy).returns(Net::HTTP)
+        Net::HTTP.expects(:start)
+      end
+      context "when not given an :authenticate option" do
+        it "should authenticate" do
+          repository.expects(:authenticate).never
+          repository.make_http_request(nil)
+        end
+      end
+      context "when given an :authenticate option" do
+        it "should authenticate" do
+          repository.expects(:authenticate)
+          repository.make_http_request(nil, :authenticate => true)
+        end
+      end
+    end
+
+    describe '#authenticate' do
+      it "should set basic auth on the request" do
+        authenticated_request = stub
+        authenticated_request.expects(:basic_auth)
+        repository.expects(:prompt).twice
+        repository.authenticate(authenticated_request)
+      end
+    end
+
+    describe '#retrieve' do
+      before do
+        @uri = URI.parse('http://some.url.com')
+      end
+
+      it "should access the cache" do
+        repository.cache.expects(:retrieve).with(@uri)
+        repository.retrieve(@uri)
+      end
+    end
+
+    describe 'http_proxy support' do
+      before :each do
+        ENV["http_proxy"] = nil
+      end
+
+      after :each do
+        ENV["http_proxy"] = nil
+      end
+
+      it "should support environment variable for port and host" do
+        ENV["http_proxy"] = "http://test.com:8011"
+        repository.http_proxy_host.should == "test.com"
+        repository.http_proxy_port.should == 8011
+      end
+
+      it "should support puppet configuration for port and host" do
+        ENV["http_proxy"] = nil
+        Puppet.settings.stubs(:[]).with(:http_proxy_host).returns('test.com')
+        Puppet.settings.stubs(:[]).with(:http_proxy_port).returns(7456)
+
+        repository.http_proxy_port.should == 7456
+        repository.http_proxy_host.should == "test.com"
+      end
+
+      it "should use environment variable before puppet settings" do
+        ENV["http_proxy"] = "http://test1.com:8011"
+        Puppet.settings.stubs(:[]).with(:http_proxy_host).returns('test2.com')
+        Puppet.settings.stubs(:[]).with(:http_proxy_port).returns(7456)
+
+        repository.http_proxy_host.should == "test1.com"
+        repository.http_proxy_port.should == 8011
+      end
+    end
+  end
+end

data/spec/unit/forge_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+require 'puppet/forge'
+require 'net/http'
+
+describe Puppet::Forge::Forge do
+  before do
+    Puppet::Forge::Repository.any_instance.stubs(:make_http_request).returns(response)
+    Puppet::Forge::Repository.any_instance.stubs(:retrieve).returns("/tmp/foo")
+  end
+
+  let(:forge) { forge = Puppet::Forge::Forge.new('http://forge.puppetlabs.com') }
+
+  describe "the behavior of the search method" do
+    context "when there are matches for the search term" do
+      before do
+        Puppet::Forge::Repository.any_instance.stubs(:make_http_request).returns(response)
+      end
+
+      let(:response) { stub(:body => response_body, :code => '200') }
+      let(:response_body) do
+      <<-EOF
+        [
+          {
+            "author": "puppetlabs",
+            "name": "bacula",
+            "tag_list": ["backup", "bacula"],
+            "releases": [{"version": "0.0.1"}, {"version": "0.0.2"}],
+            "full_name": "puppetlabs/bacula",
+            "version": "0.0.2",
+            "project_url": "http://github.com/puppetlabs/puppetlabs-bacula",
+            "desc": "bacula"
+          }
+        ]
+      EOF
+      end
+
+      it "should return a list of matches from the forge" do
+        forge.search('bacula').should == PSON.load(response_body)
+      end
+    end
+
+    context "when the connection to the forge fails" do
+      let(:response)  { stub(:body => '[]', :code => '404') }
+
+      it "should raise an error" do
+        lambda { forge.search('bacula') }.should raise_error RuntimeError
+      end
+    end
+  end
+
+  describe "the behavior of the get_release_package method" do
+
+    let(:response) do
+      response = mock()
+      response.stubs(:body).returns('{"file": "/system/releases/p/puppetlabs/puppetlabs-apache-0.0.3.tar.gz", "version": "0.0.3"}')
+      response
+    end
+
+    context "when source is not filesystem or repository" do
+      it "should raise an error" do
+        params = { :source => 'foo' }
+        lambda { forge.get_release_package(params) }.should
+          raise_error(ArgumentError, "Could not determine installation source")
+      end
+    end
+
+    context "when the source is a repository" do
+      let(:params) do
+        {
+          :source  => :repository,
+          :author  => 'fakeauthor',
+          :modname => 'fakemodule',
+          :version => '0.0.1'
+        }
+      end
+
+      it "should require author" do
+        params.delete(:author)
+        lambda { forge.get_release_package(params) }.should
+          raise_error(ArgumentError, ":author and :modename required")
+      end
+
+      it "should require modname" do
+        params.delete(:modname)
+        lambda { forge.get_release_package(params) }.should
+          raise_error(ArgumentError, ":author and :modename required")
+      end
+
+      it "should download the release package" do
+        forge.get_release_package(params).should == "/tmp/foo"
+      end
+    end
+
+    context "when the source is a filesystem" do
+      it "should require filename" do
+        params = { :source => :filesystem }
+        lambda { forge.get_release_package(params) }.should
+          raise_error(ArgumentError, ":filename required")
+      end
+    end
+  end
+
+  describe "the behavior of the get_releases method" do
+    let(:response) do
+      response = mock()
+      response.stubs(:body).returns('{"releases": [{"version": "0.0.1"}, {"version": "0.0.2"}, {"version": "0.0.3"}]}')
+      response
+    end
+
+    it "should return a list of module releases" do
+      forge.get_releases('fakeauthor', 'fakemodule').should == ["0.0.1", "0.0.2", "0.0.3"]
+    end
+  end
+end

data/spec/unit/indirector/exec_spec.rb

@@ -14,15 +14,17 @@ describe Puppet::Indirector::Exec do
     end
   end
 
+  let(:path) { File.expand_path('/echo') }
+
   before :each do
     @searcher = @exec_class.new
-    @searcher.command = ["/echo"]
+    @searcher.command = [path]
 
     @request = stub 'request', :key => "foo"
   end
 
   it "should throw an exception if the command is not an array" do
-    @searcher.command = "/usr/bin/echo"
+    @searcher.command = path
     proc { @searcher.find(@request) }.should raise_error(Puppet::DevError)
   end
 
@@ -32,22 +34,22 @@ describe Puppet::Indirector::Exec do
   end
 
   it "should execute the command with the object name as the only argument" do
-    @searcher.expects(:execute).with(%w{/echo foo}, :combine => false)
+    @searcher.expects(:execute).with([path, 'foo'], :combine => false)
     @searcher.find(@request)
   end
 
   it "should return the output of the script" do
-    @searcher.expects(:execute).with(%w{/echo foo}, :combine => false).returns("whatever")
+    @searcher.expects(:execute).with([path, 'foo'], :combine => false).returns("whatever")
     @searcher.find(@request).should == "whatever"
   end
 
   it "should return nil when the command produces no output" do
-    @searcher.expects(:execute).with(%w{/echo foo}, :combine => false).returns(nil)
+    @searcher.expects(:execute).with([path, 'foo'], :combine => false).returns(nil)
     @searcher.find(@request).should be_nil
   end
 
   it "should raise an exception if there's an execution failure" do
-    @searcher.expects(:execute).with(%w{/echo foo}, :combine => false).raises(Puppet::ExecutionFailure.new("message"))
+    @searcher.expects(:execute).with([path, 'foo'], :combine => false).raises(Puppet::ExecutionFailure.new("message"))
 
     lambda {@searcher.find(@request)}.should raise_exception(Puppet::Error, 'Failed to find foo via exec: message')
   end

data/spec/unit/indirector/facts/inventory_active_record_spec.rb

@@ -34,7 +34,6 @@ describe "Puppet::Node::Facts::InventoryActiveRecord", :if => (Puppet.features.r
 
   after :each do
     Puppet::Rails.teardown
-    ActiveRecord::Base.remove_connection
   end
 
   describe "#save" do

data/spec/unit/indirector/file_bucket_file/file_spec.rb

@@ -32,7 +32,7 @@ describe Puppet::FileBucketFile::File do
         it "should store the path if not already stored" do
           checksum = save_bucket_file("stuff\r\n", "/foo/bar")
           dir_path = "#{Puppet[:bucketdir]}/f/c/7/7/7/c/0/b/fc777c0bc467e1ab98b4c6915af802ec"
-          Puppet::Util.binread("#{dir_path}/contents").should == "stuff\r\n"
+          IO.binread("#{dir_path}/contents").should == "stuff\r\n"
           File.read("#{dir_path}/paths").should == "foo/bar\n"
         end
 

data/spec/unit/indirector/node/exec_spec.rb

@@ -6,7 +6,7 @@ require 'puppet/indirector/node/exec'
 describe Puppet::Node::Exec do
   before do
     @indirection = mock 'indirection'
-    Puppet.settings.stubs(:value).with(:external_nodes).returns("/echo")
+    Puppet.settings.stubs(:value).with(:external_nodes).returns(File.expand_path("/echo"))
     @searcher = Puppet::Node::Exec.new
   end
 

data/spec/unit/indirector/resource/active_record_spec.rb

@@ -20,10 +20,6 @@ describe "Puppet::Resource::ActiveRecord", :if => (Puppet.features.rails? and de
     Puppet[:storeconfigs] = true
   end
 
-  after :each do
-    ActiveRecord::Base.remove_connection
-  end
-
   subject {
     require 'puppet/indirector/resource/active_record'
     Puppet::Resource.indirection.terminus(:active_record)

data/spec/unit/interface/action_builder_spec.rb

@@ -114,16 +114,18 @@ describe Puppet::Interface::ActionBuilder do
           when_invoked do |options| true end
           when_rendering :json do true end
         end
-      }.to raise_error ArgumentError, /when_rendering methods take one argument, the result, not/
+      }.to raise_error ArgumentError,
+        /the puppet_interface_actionbuilder face foo action takes .* not/
     end
 
-    it "should fail if the block takes more than one argument" do
+    it "should fail if the when_rendering block takes a different number of arguments than when_invoked" do
       expect {
         Puppet::Interface::ActionBuilder.build(face, :foo) do
           when_invoked do |options| true end
           when_rendering :json do |a, b, c| true end
         end
-      }.to raise_error ArgumentError, /when_rendering methods take one argument, the result, not/
+      }.to raise_error ArgumentError,
+        /the puppet_interface_actionbuilder face foo action takes .* not 3/
     end
 
     it "should fail if the block takes a variable number of arguments" do
@@ -132,8 +134,8 @@ describe Puppet::Interface::ActionBuilder do
           when_invoked do |options| true end
           when_rendering :json do |*args| true end
         end
-      }.to raise_error(ArgumentError,
-                       /when_rendering methods take one argument, the result, not/)
+      }.to raise_error ArgumentError,
+        /the puppet_interface_actionbuilder face foo action takes .* not/
     end
 
     it "should stash a rendering block" do

data/spec/unit/module_spec.rb

@@ -1,6 +1,8 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet_spec/files'
+require 'puppet_spec/modules'
+require 'puppet/module_tool/checksums'
 
 describe Puppet::Module do
   include PuppetSpec::Files
@@ -89,6 +91,153 @@ describe Puppet::Module do
     lambda { mod.validate_puppet_version }.should raise_error(Puppet::Module::IncompatibleModule)
   end
 
+  describe "when finding unmet dependencies" do
+    before do
+      @mod = Puppet::Module.new("mymod")
+      @mod.stubs(:dependencies).returns [
+        {
+          "version_requirement" => ">= 2.2.0",
+          "name"                => "baz/foobar"
+        }
+      ]
+    end
+
+    it "should list modules that are missing" do
+      @mod.unmet_dependencies.should == [{
+        :name  => 'baz/foobar',
+        :error => <<-HEREDOC.gsub(/^\s{10}/, '')
+          Missing dependency `foobar`:
+            `mymod` () requires `baz/foobar` (>= 2.2.0)
+        HEREDOC
+      }]
+    end
+
+    it "should list modules with unmet version" do
+      foobar = Puppet::Module.new("foobar")
+      foobar.version = '2.0.0'
+      @mod.environment.expects(:module).with("foobar").returns foobar
+
+      @mod.unmet_dependencies.should == [{
+        :name  => 'baz/foobar',
+        :error => <<-HEREDOC.gsub(/^\s{10}/, '')
+          Version dependency mismatch `foobar` (2.0.0):
+            `mymod` () requires `baz/foobar` (>= 2.2.0)
+        HEREDOC
+      }]
+    end
+
+    it "should consider a dependency without a version requirement to be satisfied" do
+      mod = Puppet::Module.new("mymod")
+      mod.stubs(:dependencies).returns [{ "name" => "baz/foobar" }]
+
+      foobar = Puppet::Module.new("foobar")
+      mod.environment.expects(:module).with("foobar").returns foobar
+
+      mod.unmet_dependencies.should be_empty
+    end
+
+    it "should consider a dependency without a version to be unmet" do
+      foobar = Puppet::Module.new("foobar")
+      @mod.environment.expects(:module).with("foobar").returns foobar
+
+      @mod.unmet_dependencies.should == [{
+        :name  => 'baz/foobar',
+        :error => <<-HEREDOC.gsub(/^\s{10}/, '')
+          Unversioned dependency `foobar`:
+            `mymod` () requires `baz/foobar` (>= 2.2.0)
+        HEREDOC
+      }]
+    end
+
+    it "should consider a dependency without a semantic version to be unmet" do
+      foobar = Puppet::Module.new("foobar")
+      foobar.version = '5.1'
+      @mod.environment.expects(:module).with("foobar").returns foobar
+
+      @mod.unmet_dependencies.should == [{
+        :name  => 'baz/foobar',
+        :error => <<-HEREDOC.gsub(/^\s{10}/, '')
+          Non semantic version dependency `foobar` (5.1):
+            `mymod` () requires `baz/foobar` (>= 2.2.0)
+        HEREDOC
+      }]
+    end
+
+    it "should consider a dependency requirement without a semantic version to be unmet" do
+      foobar = Puppet::Module.new("foobar")
+      foobar.version = '5.1.0'
+
+      mod = Puppet::Module.new("mymod")
+      mod.stubs(:dependencies).returns [{ "name" => "baz/foobar", "version_requirement" => '> 2.0' }]
+      mod.environment.expects(:module).with("foobar").returns foobar
+
+      mod.unmet_dependencies.should == [{
+        :name  => 'baz/foobar',
+        :error => <<-HEREDOC.gsub(/^\s{10}/, '')
+          Non semantic version dependency `foobar` (5.1.0):
+            `mymod` () requires `baz/foobar` (> 2.0)
+        HEREDOC
+      }]
+    end
+
+    it "should have valid dependencies when no dependencies have been specified" do
+      mod = Puppet::Module.new("mymod")
+
+      mod.unmet_dependencies.should == []
+    end
+
+    it "should only list unmet dependencies" do
+      mod = Puppet::Module.new("mymod")
+      mod.stubs(:dependencies).returns [
+        {
+          "version_requirement" => ">= 2.2.0",
+          "name"                => "baz/satisfied"
+        },
+        {
+          "version_requirement" => ">= 2.2.0",
+          "name"                => "baz/notsatisfied"
+        }
+      ]
+
+      satisfied = Puppet::Module.new("satisfied")
+      satisfied.version = "3.3.0"
+
+      mod.environment.expects(:module).with("satisfied").returns satisfied
+      mod.environment.expects(:module).with("notsatisfied").returns nil
+
+      mod.unmet_dependencies.should == [{
+        :name  => 'baz/notsatisfied',
+        :error => <<-HEREDOC.gsub(/^\s{10}/, '')
+          Missing dependency `notsatisfied`:
+            `mymod` () requires `baz/notsatisfied` (>= 2.2.0)
+        HEREDOC
+      }]
+    end
+
+    it "should be empty when all dependencies are met" do
+      mod = Puppet::Module.new("mymod")
+      mod.stubs(:dependencies).returns [
+        {
+          "version_requirement" => ">= 2.2.0",
+          "name"                => "baz/satisfied"
+        },
+        {
+          "version_requirement" => "< 2.2.0",
+          "name"                => "baz/alsosatisfied"
+        }
+      ]
+      satisfied = Puppet::Module.new("satisfied")
+      satisfied.version = "3.3.0"
+      alsosatisfied = Puppet::Module.new("alsosatisfied")
+      alsosatisfied.version = "2.1.0"
+
+      mod.environment.expects(:module).with("satisfied").returns satisfied
+      mod.environment.expects(:module).with("alsosatisfied").returns alsosatisfied
+
+      mod.unmet_dependencies.should be_empty
+    end
+  end
+
   describe "when managing supported platforms" do
     it "should support specifying a supported platform" do
       mod = Puppet::Module.new("mymod")
@@ -385,13 +534,14 @@ describe Puppet::Module, "when finding matching manifests" do
 end
 
 describe Puppet::Module do
+  include PuppetSpec::Files
   before do
-    Puppet::Module.any_instance.stubs(:path).returns "/my/mod/path"
-    @module = Puppet::Module.new("foo")
+    @modpath = tmpdir('modpath')
+    @module = PuppetSpec::Modules.create('mymod', @modpath)
   end
 
   it "should use 'License' in its current path as its metadata file" do
-    @module.license_file.should == "/my/mod/path/License"
+    @module.license_file.should == "#{@modpath}/mymod/License"
   end
 
   it "should return nil as its license file when the module has no path" do
@@ -400,13 +550,13 @@ describe Puppet::Module do
   end
 
   it "should cache the license file" do
-    Puppet::Module.any_instance.expects(:path).once.returns nil
-    mod = Puppet::Module.new("foo")
-    mod.license_file.should == mod.license_file
+    @module.expects(:path).once.returns nil
+    @module.license_file
+    @module.license_file
   end
 
   it "should use 'metadata.json' in its current path as its metadata file" do
-    @module.metadata_file.should == "/my/mod/path/metadata.json"
+    @module.metadata_file.should == "#{@modpath}/mymod/metadata.json"
   end
 
   it "should return nil as its metadata file when the module has no path" do
@@ -469,14 +619,15 @@ describe Puppet::Module do
     Puppet::Module.new("yay")
   end
 
-  describe "when loading the medatada file", :if => Puppet.features.pson? do
+  describe "when loading the metadata file", :if => Puppet.features.pson? do
     before do
       @data = {
         :license       => "GPL2",
         :author        => "luke",
         :version       => "1.0",
         :source        => "http://foo/",
-        :puppetversion => "0.25"
+        :puppetversion => "0.25",
+        :dependencies  => []
       }
       @text = @data.to_pson
 
@@ -509,4 +660,72 @@ describe Puppet::Module do
 
     it "should fail if the discovered name is different than the metadata name"
   end
+
+  it "should be able to tell if there are local changes" do
+    modpath = tmpdir('modpath')
+    foo_checksum = 'acbd18db4cc2f85cedef654fccc4a4d8'
+    checksummed_module = PuppetSpec::Modules.create(
+      'changed',
+      modpath,
+      :metadata => {
+        :checksums => {
+          "foo" => foo_checksum,
+        }
+      }
+    )
+
+    foo_path = Pathname.new(File.join(checksummed_module.path, 'foo'))
+
+    IO.binwrite(foo_path, 'notfoo')
+    Puppet::Module::Tool::Checksums.new(foo_path).checksum(foo_path).should_not == foo_checksum
+    checksummed_module.has_local_changes?.should be_true
+
+    IO.binwrite(foo_path, 'foo')
+
+    Puppet::Module::Tool::Checksums.new(foo_path).checksum(foo_path).should == foo_checksum
+    checksummed_module.has_local_changes?.should be_false
+  end
+
+  it "should know what other modules require it" do
+    Puppet.settings[:modulepath] = @modpath
+    dependable = PuppetSpec::Modules.create(
+      'dependable',
+      @modpath,
+      :metadata => {:author => 'puppetlabs'}
+    )
+    PuppetSpec::Modules.create(
+      'needy',
+      @modpath,
+      :metadata => {
+        :author => 'beggar',
+        :dependencies => [{
+            "version_requirement" => ">= 2.2.0",
+            "name" => "puppetlabs/dependable"
+        }]
+      }
+    )
+    PuppetSpec::Modules.create(
+      'wantit',
+      @modpath,
+      :metadata => {
+        :author => 'spoiled',
+        :dependencies => [{
+            "version_requirement" => "< 5.0.0",
+            "name" => "puppetlabs/dependable"
+        }]
+      }
+    )
+    dependable.required_by.should =~ [
+      {
+        "name"    => "beggar/needy",
+        "version" => "9.9.9",
+        "version_requirement" => ">= 2.2.0"
+      },
+      {
+        "name"    => "spoiled/wantit",
+        "version" => "9.9.9",
+        "version_requirement" => "< 5.0.0"
+      }
+    ]
+  end
 end