puppet 2.7.13 → 2.7.14

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

@@ -1,24 +1,18 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
-begin
-  require 'sqlite3'
-rescue LoadError
-end
-require 'tempfile'
 require 'puppet/rails'
 
-describe "Puppet::Node::Facts::InventoryActiveRecord", :if => (Puppet.features.rails? and defined? SQLite3) do
+describe "Puppet::Node::Facts::InventoryActiveRecord", :if => can_use_scratch_database? do
+  include PuppetSpec::Files
+
   let(:terminus) { Puppet::Node::Facts::InventoryActiveRecord.new }
 
   before :all do
     require 'puppet/indirector/facts/inventory_active_record'
-    @dbfile = Tempfile.new("testdb")
-    @dbfile.close
   end
 
-  after :all do
+  after :each do
     Puppet::Node::Facts.indirection.reset_terminus_class
-    @dbfile.unlink
   end
 
   before :each do
@@ -26,14 +20,7 @@ describe "Puppet::Node::Facts::InventoryActiveRecord", :if => (Puppet.features.r
     Puppet::Node.indirection.cache_class = nil
 
     Puppet::Node::Facts.indirection.terminus_class = :inventory_active_record
-    Puppet[:dbadapter]  = 'sqlite3'
-    Puppet[:dblocation] = @dbfile.path
-    Puppet[:railslog] = "/dev/null"
-    Puppet::Rails.init
-  end
-
-  after :each do
-    Puppet::Rails.teardown
+    setup_scratch_database
   end
 
   describe "#save" do

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

@@ -1,22 +1,13 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
-
-begin
-  require 'sqlite3'
-rescue LoadError
-end
-
 require 'puppet/rails'
 require 'puppet/node/facts'
 
-describe "Puppet::Resource::ActiveRecord", :if => (Puppet.features.rails? and defined? SQLite3) do
+describe "Puppet::Resource::ActiveRecord", :if => can_use_scratch_database? do
   include PuppetSpec::Files
 
   before :each do
-    dir = Pathname(tmpdir('puppet-var'))
-    Puppet[:vardir]       = dir.to_s
-    Puppet[:dbadapter]    = 'sqlite3'
-    Puppet[:dblocation]   = (dir + 'storeconfigs.sqlite').to_s
+    setup_scratch_database
     Puppet[:storeconfigs] = true
   end
 

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

@@ -20,12 +20,17 @@ describe "Puppet::Resource::Ral" do
 
     it "if there is no instance, it should create one", :'fails_on_ruby_1.9.2' => true do
       wrong_instance = stub "wrong user", :name => "bob"
+      root = mock "Root User"
+      root_resource = mock "Root Resource"
 
       require 'puppet/type/user'
       Puppet::Type::User.expects(:instances).returns([ wrong_instance, wrong_instance ])
+      Puppet::Type::User.expects(:new).with(has_entry(:name => "root")).returns(root)
+      root.expects(:to_resource).returns(root_resource)
+
       result = Puppet::Resource::Ral.new.find(@request)
-      result.should be_is_a(Puppet::Resource)
-      result.title.should == "root"
+
+      result.should == root_resource
     end
   end
 

data/spec/unit/module_spec.rb

@@ -93,146 +93,227 @@ describe Puppet::Module do
 
   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"
-        }
-      ]
+      FileTest.unstub(:exist?)
+      @modpath = tmpdir('modpath')
+      Puppet.settings[:modulepath] = @modpath
     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
+      mod = PuppetSpec::Modules.create(
+        'needy',
+        @modpath,
+        :metadata => {
+          :dependencies => [{
+            "version_requirement" => ">= 2.2.0",
+            "name" => "baz/foobar"
+          }]
+        }
+      )
+      mod.unmet_dependencies.should == [{
+        :reason => :missing,
+        :name   => "baz/foobar",
+        :version_constraint => ">= 2.2.0",
+        :parent => { :name => 'puppetlabs/needy', :version => 'v9.9.9' },
+        :mod_details => { :installed_version => nil }
       }]
     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
+    it "should list modules that are missing and have invalid names" do
+      mod = PuppetSpec::Modules.create(
+        'needy',
+        @modpath,
+        :metadata => {
+          :dependencies => [{
+            "version_requirement" => ">= 2.2.0",
+            "name" => "baz/foobar=bar"
+          }]
+        }
+      )
+      mod.unmet_dependencies.should == [{
+        :reason => :missing,
+        :name   => "baz/foobar=bar",
+        :version_constraint => ">= 2.2.0",
+        :parent => { :name => 'puppetlabs/needy', :version => 'v9.9.9' },
+        :mod_details => { :installed_version => nil }
       }]
     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 list modules with unmet version requirement" do
+      mod = PuppetSpec::Modules.create(
+        'foobar',
+        @modpath,
+        :metadata => {
+          :dependencies => [{
+            "version_requirement" => ">= 2.2.0",
+            "name" => "baz/foobar"
+          }]
+        }
+      )
+      mod2 = PuppetSpec::Modules.create(
+        'foobaz',
+        @modpath,
+        :metadata => {
+          :dependencies => [{
+            "version_requirement" => "1.0.0",
+            "name" => "baz/foobar"
+          }]
+        }
+      )
 
-    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
+      PuppetSpec::Modules.create(
+        'foobar',
+        @modpath,
+        :metadata => { :version => '2.0.0', :author  => 'baz' }
+      )
 
-      @mod.unmet_dependencies.should == [{
-        :name  => 'baz/foobar',
-        :error => <<-HEREDOC.gsub(/^\s{10}/, '')
-          Unversioned dependency `foobar`:
-            `mymod` () requires `baz/foobar` (>= 2.2.0)
-        HEREDOC
+      mod.unmet_dependencies.should == [{
+        :reason => :version_mismatch,
+        :name   => "baz/foobar",
+        :version_constraint => ">= 2.2.0",
+        :parent => { :version => "v9.9.9", :name => "puppetlabs/foobar" },
+        :mod_details => { :installed_version => "2.0.0" }
       }]
-    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
+      mod2.unmet_dependencies.should == [{
+        :reason => :version_mismatch,
+        :name   => "baz/foobar",
+        :version_constraint => "v1.0.0",
+        :parent => { :version => "v9.9.9", :name => "puppetlabs/foobaz" },
+        :mod_details => { :installed_version => "2.0.0" }
       }]
+
     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'
+    it "should consider a dependency without a version requirement to be satisfied" do
+      mod = PuppetSpec::Modules.create(
+        'foobar',
+        @modpath,
+        :metadata => {
+          :dependencies => [{
+            "name" => "baz/foobar"
+          }]
+        }
+      )
+      PuppetSpec::Modules.create(
+        'foobar',
+        @modpath,
+        :metadata => {
+          :version => '2.0.0',
+          :author  => 'baz'
+        }
+      )
+
+      mod.unmet_dependencies.should be_empty
+    end
 
-      mod = Puppet::Module.new("mymod")
-      mod.stubs(:dependencies).returns [{ "name" => "baz/foobar", "version_requirement" => '> 2.0' }]
-      mod.environment.expects(:module).with("foobar").returns foobar
+    it "should consider a dependency without a semantic version to be unmet" do
+      mod = PuppetSpec::Modules.create(
+        'foobar',
+        @modpath,
+        :metadata => {
+          :dependencies => [{
+            "name" => "baz/foobar"
+          }]
+        }
+      )
+      PuppetSpec::Modules.create(
+        'foobar',
+        @modpath,
+        :metadata => {
+          :version => '5.1',
+          :author  => 'baz'
+        }
+      )
 
       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
+        :reason => :non_semantic_version,
+        :parent => { :version => "v9.9.9", :name => "puppetlabs/foobar" },
+        :mod_details => { :installed_version => "5.1" },
+        :name => "baz/foobar",
+        :version_constraint => ">= 0.0.0"
       }]
     end
 
     it "should have valid dependencies when no dependencies have been specified" do
-      mod = Puppet::Module.new("mymod")
+      mod = PuppetSpec::Modules.create(
+        'foobar',
+        @modpath,
+        :metadata => {
+          :dependencies => []
+        }
+      )
 
       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"
+      mod = PuppetSpec::Modules.create(
+        'mymod',
+        @modpath,
+        :metadata => {
+          :dependencies => [
+            {
+              "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
+      )
+      PuppetSpec::Modules.create(
+        'satisfied',
+        @modpath,
+        :metadata => {
+          :version => '3.3.0',
+          :author  => 'baz'
+        }
+      )
 
       mod.unmet_dependencies.should == [{
-        :name  => 'baz/notsatisfied',
-        :error => <<-HEREDOC.gsub(/^\s{10}/, '')
-          Missing dependency `notsatisfied`:
-            `mymod` () requires `baz/notsatisfied` (>= 2.2.0)
-        HEREDOC
+        :reason => :missing,
+        :mod_details => { :installed_version => nil },
+        :parent => { :version => "v9.9.9", :name => "puppetlabs/mymod" },
+        :name => "baz/notsatisfied",
+        :version_constraint => ">= 2.2.0"
       }]
     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"
+      mod = PuppetSpec::Modules.create(
+        'mymod2',
+        @modpath,
+        :metadata => {
+          :dependencies => [
+            {
+              "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
+      )
+      PuppetSpec::Modules.create(
+        'satisfied',
+        @modpath,
+        :metadata => {
+          :version => '3.3.0',
+          :author  => 'baz'
+        }
+      )
+      PuppetSpec::Modules.create(
+        'alsosatisfied',
+        @modpath,
+        :metadata => {
+          :version => '2.1.0',
+          :author  => 'baz'
+        }
+      )
 
       mod.unmet_dependencies.should be_empty
     end
@@ -386,6 +467,20 @@ describe Puppet::Module do
     end
   end
 
+  describe '#modulepath' do
+    it "should return the directory the module is installed in, if a path exists" do
+      mod = Puppet::Module.new("foo")
+      mod.stubs(:path).returns "/a/foo"
+      mod.modulepath.should == '/a'
+    end
+
+    it "should return nil if no path exists" do
+      mod = Puppet::Module.new("foo")
+      mod.stubs(:path).returns nil
+      mod.modulepath.should be_nil
+    end
+  end
+
   it "should be considered existent if it exists in at least one module path" do
     mod = Puppet::Module.new("foo")
     mod.expects(:path).returns "/a/foo"
@@ -658,10 +753,48 @@ describe Puppet::Module do
       @module.puppetversion.should == @data[:puppetversion]
     end
 
+    context "when versionRequirement is used for dependency version info" do
+      before do
+        @data = {
+          :license       => "GPL2",
+          :author        => "luke",
+          :version       => "1.0",
+          :source        => "http://foo/",
+          :puppetversion => "0.25",
+          :dependencies  => [
+            {
+              "versionRequirement" => "0.0.1",
+              "name" => "pmtacceptance/stdlib"
+            },
+            {
+              "versionRequirement" => "0.1.0",
+              "name" => "pmtacceptance/apache"
+            }
+          ]
+        }
+        @text = @data.to_pson
+
+        @module = Puppet::Module.new("foo")
+        @module.stubs(:metadata_file).returns "/my/file"
+        File.stubs(:read).with("/my/file").returns @text
+      end
+
+      it "should set the dependency version_requirement key" do
+        @module.load_metadata
+        @module.dependencies[0]['version_requirement'].should == "0.0.1"
+      end
+
+      it "should set the version_requirement key for all dependencies" do
+        @module.load_metadata
+        @module.dependencies[0]['version_requirement'].should == "0.0.1"
+        @module.dependencies[1]['version_requirement'].should == "0.1.0"
+      end
+    end
+
     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
+  it "should be able to tell if there are local changes", :fails_on_windows => true do
     modpath = tmpdir('modpath')
     foo_checksum = 'acbd18db4cc2f85cedef654fccc4a4d8'
     checksummed_module = PuppetSpec::Modules.create(
@@ -677,12 +810,12 @@ describe Puppet::Module do
     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
+    Puppet::ModuleTool::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
+    Puppet::ModuleTool::Checksums.new(foo_path).checksum(foo_path).should == foo_checksum
     checksummed_module.has_local_changes?.should be_false
   end