puppet 2.7.11 → 2.7.12

data/spec/unit/node/environment_spec.rb

@@ -5,6 +5,7 @@ require 'tmpdir'
 
 require 'puppet/node/environment'
 require 'puppet/util/execution'
+require 'puppet_spec/modules'
 
 describe Puppet::Node::Environment do
   let(:env) { Puppet::Node::Environment.new("testing") }
@@ -124,8 +125,10 @@ describe Puppet::Node::Environment do
 
   describe "when validating modulepath or manifestdir directories" do
     before :each do
-      @path_one = make_absolute('/one')
-      @path_two = make_absolute('/two')
+      @path_one = tmpdir("path_one")
+      @path_two = tmpdir("path_one")
+      sep = File::PATH_SEPARATOR
+      Puppet[:modulepath] = "#{@path_one}#{sep}#{@path_two}"
     end
 
     it "should not return non-directories" do
@@ -167,15 +170,13 @@ describe Puppet::Node::Environment do
     end
 
     it "should return nil if asked for a module that does not exist in its path" do
-
-      mod = mock 'module'
-      Puppet::Module.expects(:new).with("one", :environment => env).returns mod
-      mod.expects(:exist?).returns false
+      modpath = tmpdir('modpath')
+      env.modulepath = [modpath]
 
       env.module("one").should be_nil
     end
 
-    describe ".modules_by_path" do
+    describe "module data" do
       before do
         dir = tmpdir("deep_path")
 
@@ -187,75 +188,167 @@ describe Puppet::Node::Environment do
         FileUtils.mkdir_p(@second)
       end
 
-      it "should return an empty list if there are no modules" do
-        env.modules_by_path.should == {
-          @first  => [],
-          @second => []
-        }
-      end
-
-      it "should include modules even if they exist in multiple dirs in the modulepath" do
-        modpath1 = File.join(@first, "foo")
-        FileUtils.mkdir_p(modpath1)
-        modpath2 = File.join(@second, "foo")
-        FileUtils.mkdir_p(modpath2)
-
-        env.modules_by_path.should == {
-          @first  => [Puppet::Module.new('foo', :environment => env, :path => modpath1)],
-          @second => [Puppet::Module.new('foo', :environment => env, :path => modpath2)]
-        }
-      end
-    end
-
-    describe ".modules" do
-      it "should return an empty list if there are no modules" do
-        env.modulepath = %w{/a /b}
-        Dir.expects(:entries).with("/a").returns []
-        Dir.expects(:entries).with("/b").returns []
-
-        env.modules.should == []
-      end
-
-      it "should return a module named for every directory in each module path" do
-        env.modulepath = %w{/a /b}
-        Dir.expects(:entries).with("/a").returns %w{foo bar}
-        Dir.expects(:entries).with("/b").returns %w{bee baz}
-
-        env.modules.collect{|mod| mod.name}.sort.should == %w{foo bar bee baz}.sort
+      describe "#modules_by_path" do
+        it "should return an empty list if there are no modules" do
+          env.modules_by_path.should == {
+            @first  => [],
+            @second => []
+          }
+        end
+
+        it "should include modules even if they exist in multiple dirs in the modulepath" do
+          modpath1 = File.join(@first, "foo")
+          FileUtils.mkdir_p(modpath1)
+          modpath2 = File.join(@second, "foo")
+          FileUtils.mkdir_p(modpath2)
+
+          env.modules_by_path.should == {
+            @first  => [Puppet::Module.new('foo', :environment => env, :path => modpath1)],
+            @second => [Puppet::Module.new('foo', :environment => env, :path => modpath2)]
+          }
+        end
       end
 
-      it "should remove duplicates" do
-        env.modulepath = %w{/a /b}
-        Dir.expects(:entries).with("/a").returns %w{foo}
-        Dir.expects(:entries).with("/b").returns %w{foo}
-
-        env.modules.collect{|mod| mod.name}.sort.should == %w{foo}
+      describe "#module_requirements" do
+        it "should return a list of what modules depend on other modules" do
+          PuppetSpec::Modules.create(
+            'foo',
+            @first,
+            :metadata => {
+              :author       => 'puppetlabs',
+              :dependencies => [{ 'name' => 'puppetlabs/bar', "version_requirement" => ">= 1.0.0" }]
+            }
+          )
+          PuppetSpec::Modules.create(
+            'bar',
+            @second,
+            :metadata => {
+              :author       => 'puppetlabs',
+              :dependencies => [{ 'name' => 'puppetlabs/foo', "version_requirement" => "<= 2.0.0" }]
+            }
+          )
+          PuppetSpec::Modules.create(
+            'baz',
+            @first,
+            :metadata => {
+              :author       => 'puppetlabs',
+              :dependencies => [{ 'name' => 'puppetlabs/bar', "version_requirement" => "3.0.0" }]
+            }
+          )
+          PuppetSpec::Modules.create(
+            'alpha',
+            @first,
+            :metadata => {
+              :author       => 'puppetlabs',
+              :dependencies => [{ 'name' => 'puppetlabs/bar', "version_requirement" => "~3.0.0" }]
+            }
+          )
+
+          env.module_requirements.should == {
+            'puppetlabs/alpha' => [],
+            'puppetlabs/foo' => [
+              {
+                "name"    => "puppetlabs/bar",
+                "version" => "9.9.9",
+                "version_requirement" => "<= 2.0.0"
+              }
+            ],
+            'puppetlabs/bar' => [
+              {
+                "name"    => "puppetlabs/alpha",
+                "version" => "9.9.9",
+                "version_requirement" => "~3.0.0"
+              },
+              {
+                "name"    => "puppetlabs/baz",
+                "version" => "9.9.9",
+                "version_requirement" => "3.0.0"
+              },
+              {
+                "name"    => "puppetlabs/foo",
+                "version" => "9.9.9",
+                "version_requirement" => ">= 1.0.0"
+              }
+            ],
+            'puppetlabs/baz' => []
+          }
+        end
       end
 
-      it "should ignore invalid modules" do
-        env.modulepath = %w{/a}
-        Dir.expects(:entries).with("/a").returns %w{foo bar}
-
-        Puppet::Module.expects(:new).with { |name, env| name == "foo" }.returns mock("foomod", :name => "foo")
-        Puppet::Module.expects(:new).with { |name, env| name == "bar" }.raises( Puppet::Module::InvalidName, "name is invalid" )
-
-        env.modules.collect{|mod| mod.name}.sort.should == %w{foo}
+      describe ".module_by_forge_name" do
+        it "should find modules by forge_name" do
+          mod = PuppetSpec::Modules.create(
+            'baz',
+            @first,
+            :metadata => {:author => 'puppetlabs'},
+            :environment => env
+          )
+          env.module_by_forge_name('puppetlabs/baz').should == mod
+        end
+
+        it "should not find modules with same name by the wrong author" do
+          mod = PuppetSpec::Modules.create(
+            'baz',
+            @first,
+            :metadata => {:author => 'sneakylabs'},
+            :environment => env
+          )
+          env.module_by_forge_name('puppetlabs/baz').should == nil
+        end
+
+        it "should return nil when the module can't be found" do
+          env.module_by_forge_name('ima/nothere').should be_nil
+        end
       end
 
-      it "should create modules with the correct environment" do
-        env.modulepath = %w{/a}
-        Dir.expects(:entries).with("/a").returns %w{foo}
+      describe ".modules" do
+        it "should return an empty list if there are no modules" do
+          env.modules.should == []
+        end
+
+        it "should return a module named for every directory in each module path" do
+          %w{foo bar}.each do |mod_name|
+            FileUtils.mkdir_p(File.join(@first, mod_name))
+          end
+          %w{bee baz}.each do |mod_name|
+            FileUtils.mkdir_p(File.join(@second, mod_name))
+          end
+          env.modules.collect{|mod| mod.name}.sort.should == %w{foo bar bee baz}.sort
+        end
+
+        it "should remove duplicates" do
+          FileUtils.mkdir_p(File.join(@first,  'foo'))
+          FileUtils.mkdir_p(File.join(@second, 'foo'))
+
+          env.modules.collect{|mod| mod.name}.sort.should == %w{foo}
+        end
+
+        it "should ignore modules with invalid names" do
+          FileUtils.mkdir_p(File.join(@first, 'foo'))
+          FileUtils.mkdir_p(File.join(@first, 'foo2'))
+          FileUtils.mkdir_p(File.join(@first, 'foo-bar'))
+          FileUtils.mkdir_p(File.join(@first, 'foo_bar'))
+          FileUtils.mkdir_p(File.join(@first, 'foo=bar'))
+          FileUtils.mkdir_p(File.join(@first, 'foo bar'))
+
+          env.modules.collect{|mod| mod.name}.sort.should == %w{foo foo-bar foo2 foo_bar}
+        end
+
+        it "should create modules with the correct environment" do
+          FileUtils.mkdir_p(File.join(@first, 'foo'))
+
+          env.modules.each {|mod| mod.environment.should == env }
+        end
 
-        env.modules.each {|mod| mod.environment.should == env }
       end
+    end
 
-      it "should cache the module list" do
-        env.modulepath = %w{/a}
-        Dir.expects(:entries).once.with("/a").returns %w{foo}
+    it "should cache the module list" do
+      env.modulepath = %w{/a}
+      Dir.expects(:entries).once.with("/a").returns %w{foo}
 
-        env.modules
-        env.modules
-      end
+      env.modules
+      env.modules
     end
   end
 

data/spec/unit/parser/collector_spec.rb

@@ -287,21 +287,16 @@ describe Puppet::Parser::Collector, "when collecting exported resources", :if =>
 
   context "with storeconfigs enabled" do
     before :each do
-      ActiveRecord::Base.remove_connection
-
       dir = Pathname(tmpdir('puppet-var'))
       Puppet[:vardir]       = dir.to_s
       Puppet[:dbadapter]    = 'sqlite3'
       Puppet[:dblocation]   = (dir + 'storeconfigs.sqlite').to_s
       Puppet[:storeconfigs] = true
       Puppet[:environment]  = "production"
+      Puppet[:storeconfigs_backend] = "active_record"
       Puppet::Rails.init
     end
 
-    after :each do
-      ActiveRecord::Base.remove_connection
-    end
-
     it "should return all matching resources from the current compile and mark them non-virtual and non-exported" do
       one = Puppet::Parser::Resource.new('notify', 'one',
                                          :virtual  => true,
@@ -336,7 +331,7 @@ describe Puppet::Parser::Collector, "when collecting exported resources", :if =>
       one.should_not be_virtual
     end
 
-    it "should convert all found resources into parser resources" do
+    it "should convert all found resources into parser resources if necessary" do
       host = Puppet::Rails::Host.create!(:name => 'one.local')
       Puppet::Rails::Resource.
         create!(:host     => host,
@@ -350,6 +345,19 @@ describe Puppet::Parser::Collector, "when collecting exported resources", :if =>
       result.first.title.should == 'whammo'
     end
 
+    it "should leave parser resources alone" do
+      resource = Puppet::Parser::Resource.new(:file, "/tmp/foo", :scope => @scope)
+      resource2 = Puppet::Parser::Resource.new(:file, "/tmp/bar", :scope => @scope)
+      resource.expects(:to_resource).never
+      resource2.expects(:to_resource).never
+
+      resources = [resource, resource2]
+
+      Puppet::Resource.indirection.stubs(:search).returns resources
+
+      @collector.evaluate.should == resources
+    end
+
     it "should override all exported collected resources if collector has an override" do
       host = Puppet::Rails::Host.create!(:name => 'one.local')
       Puppet::Rails::Resource.
@@ -408,7 +416,7 @@ describe Puppet::Parser::Collector, "when collecting exported resources", :if =>
       @compiler.add_resource(@scope, local)
 
       expect { @collector.evaluate }.
-        to raise_error Puppet::ParseError, /cannot override local resource/
+        to raise_error Puppet::ParseError, /exists with the type and title/
     end
 
     it "should ignore exported resources that match already-collected resources" do

data/spec/unit/parser/functions/generate_spec.rb

@@ -6,38 +6,80 @@ describe "the generate function" do
     Puppet::Parser::Functions.autoloader.loadall
   end
 
-  before :each do
-    @scope = Puppet::Parser::Scope.new
-  end
+  let(:scope) { Puppet::Parser::Scope.new }
 
   it "should exist" do
     Puppet::Parser::Functions.function("generate").should == "function_generate"
   end
 
-  it "should accept a fully-qualified path as a command" do
-    command = File::SEPARATOR + "command"
-    Puppet::Util.expects(:execute).with([command]).returns("yay")
-    lambda { @scope.function_generate([command]) }.should_not raise_error(Puppet::ParseError)
+  it " accept a fully-qualified path as a command" do
+    command = File.expand_path('/command/foo')
+    Dir.expects(:chdir).with(File.dirname(command)).returns("yay")
+    scope.function_generate([command]).should == "yay"
   end
 
   it "should not accept a relative path as a command" do
-    command = "command"
-    lambda { @scope.function_generate([command]) }.should raise_error(Puppet::ParseError)
+    lambda { scope.function_generate(["command"]) }.should raise_error(Puppet::ParseError)
+  end
+
+  it "should not accept a command containing illegal characters" do
+    lambda { scope.function_generate([File.expand_path('/##/command')]) }.should raise_error(Puppet::ParseError)
   end
 
-  # Really not sure how to implement this test, just sure it needs
-  # to be implemented.
-  it "should not accept a command containing illegal characters"
+  it "should not accept a command containing spaces" do
+    lambda { scope.function_generate([File.expand_path('/com mand')]) }.should raise_error(Puppet::ParseError)
+  end
 
   it "should not accept a command containing '..'" do
-    command = File::SEPARATOR + "command#{File::SEPARATOR}..#{File::SEPARATOR}"
-    lambda { @scope.function_generate([command]) }.should raise_error(Puppet::ParseError)
+    command = File.expand_path("/command/../")
+    lambda { scope.function_generate([command]) }.should raise_error(Puppet::ParseError)
   end
 
   it "should execute the generate script with the correct working directory" do
-    command = File::SEPARATOR + "command"
-    Dir.expects(:chdir).with(File.dirname(command)).yields
-    Puppet::Util.expects(:execute).with([command]).returns("yay")
-    lambda { @scope.function_generate([command]) }.should_not raise_error(Puppet::ParseError)
+    command = File.expand_path("/command")
+    Dir.expects(:chdir).with(File.dirname(command)).returns("yay")
+    scope.function_generate([command]).should == 'yay'
+  end
+
+  describe "on Windows" do
+    before :each do
+      Puppet.features.stubs(:microsoft_windows?).returns(true)
+    end
+
+    it "should accept lower-case drive letters" do
+      command = 'd:/command/foo'
+      Dir.expects(:chdir).with(File.dirname(command)).returns("yay")
+      scope.function_generate([command]).should == 'yay'
+    end
+
+    it "should accept upper-case drive letters" do
+      command = 'D:/command/foo'
+      Dir.expects(:chdir).with(File.dirname(command)).returns("yay")
+      scope.function_generate([command]).should == 'yay'
+    end
+
+    it "should accept forward and backslashes in the path" do
+      command = 'D:\command/foo\bar'
+      Dir.expects(:chdir).with(File.dirname(command)).returns("yay")
+      scope.function_generate([command]).should == 'yay'
+    end
+
+    it "should reject colons when not part of the drive letter" do
+      lambda { scope.function_generate(['C:/com:mand']) }.should raise_error(Puppet::ParseError)
+    end
+
+    it "should reject root drives" do
+      lambda { scope.function_generate(['C:/']) }.should raise_error(Puppet::ParseError)
+    end
+  end
+
+  describe "on non-Windows" do
+    before :each do
+      Puppet.features.stubs(:microsoft_windows?).returns(false)
+    end
+
+    it "should reject backslashes" do
+      lambda { scope.function_generate(['/com\\mand']) }.should raise_error(Puppet::ParseError)
+    end
   end
 end

data/spec/unit/parser/resource_spec.rb

@@ -200,6 +200,50 @@ describe Puppet::Parser::Resource do
       @compiler.catalog.should be_edge(foo_stage, resource)
     end
 
+    it "should allow edges to propagate multiple levels down the scope hierarchy" do
+      Puppet[:code] = <<-MANIFEST
+        stage { before: before => Stage[main] }
+
+        class alpha {
+          include beta
+        }
+        class beta {
+          include gamma
+        }
+        class gamma { }
+        class { alpha: stage => before }
+      MANIFEST
+
+      catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new 'anyone')
+
+      # Stringify them to make for easier lookup
+      edges = catalog.edges.map {|e| [e.source.ref, e.target.ref]}
+
+      edges.should include(["Stage[before]", "Class[Alpha]"])
+      edges.should include(["Stage[before]", "Class[Beta]"])
+      edges.should include(["Stage[before]", "Class[Gamma]"])
+    end
+
+    it "should use the specified stage even if the parent scope specifies one" do
+      Puppet[:code] = <<-MANIFEST
+        stage { before: before => Stage[main], }
+        stage { after: require => Stage[main], }
+
+        class alpha {
+          class { beta: stage => after }
+        }
+        class beta { }
+        class { alpha: stage => before }
+      MANIFEST
+
+      catalog = Puppet::Parser::Compiler.compile(Puppet::Node.new 'anyone')
+
+      edges = catalog.edges.map {|e| [e.source.ref, e.target.ref]}
+
+      edges.should include(["Stage[before]", "Class[Alpha]"])
+      edges.should include(["Stage[after]", "Class[Beta]"])
+    end
+
     it "should add edges from top-level class resources to the main stage if no stage is specified", :'fails_on_ruby_1.9.2' => true do
       main = @compiler.catalog.resource(:stage, :main)
       @compiler.known_resource_types.add Puppet::Resource::Type.new(:hostclass, "foo", '')