puppet 2.7.13 → 2.7.14

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

@@ -0,0 +1,37 @@
+require 'spec_helper'
+require 'puppet/module_tool/applications'
+require 'puppet_spec/modules'
+require 'semver'
+
+describe Puppet::ModuleTool::Applications::Upgrader, :fails_on_windows => true do
+  include PuppetSpec::Files
+
+  before do
+  end
+
+  it "should update the requested module"
+  it "should not update dependencies"
+  it "should fail when updating a dependency to an unsupported version"
+  it "should fail when updating a module that is not installed"
+  it "should warn when the latest version is already installed"
+  it "should warn when the best version is already installed"
+
+  context "when using the '--version' option" do
+    it "should update an installed module to the requested version"
+  end
+
+  context "when using the '--force' flag" do
+    it "should ignore missing dependencies"
+    it "should ignore version constraints"
+    it "should not update a module that is not installed"
+  end
+
+  context "when using the '--env' option" do
+    it "should use the correct environment"
+  end
+
+  context "when there are missing dependencies" do
+    it "should fail to upgrade the original module"
+    it "should raise an error"
+  end
+end

data/spec/unit/module_tool/metadata_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 require 'puppet/module_tool'
 
-describe Puppet::Module::Tool::Metadata do
+describe Puppet::ModuleTool::Metadata do
   context "when using default values" do
     it "should set license to 'Apache License, Version 2.0'" do
-      metadata = Puppet::Module::Tool::Metadata.new
+      metadata = Puppet::ModuleTool::Metadata.new
       metadata.license.should == "Apache License, Version 2.0"
     end
   end

data/spec/unit/module_tool_spec.rb

@@ -1,5 +1,113 @@
+# encoding: UTF-8
+
 require 'spec_helper'
 require 'puppet/module_tool'
 
-describe Puppet::Module::Tool do
+describe Puppet::ModuleTool, :fails_on_windows => true do
+  describe '.format_tree' do
+    it 'should return an empty tree when given an empty list' do
+      subject.format_tree([]).should == ''
+    end
+
+    it 'should return a shallow when given a list without dependencies' do
+      list = [ { :text => 'first' }, { :text => 'second' }, { :text => 'third' } ]
+      subject.format_tree(list).should == <<-TREE
+├── first
+├── second
+└── third
+TREE
+    end
+
+    it 'should return a deeply nested tree when given a list with deep dependencies' do
+      list = [
+        {
+          :text => 'first',
+          :dependencies => [
+            {
+              :text => 'second',
+              :dependencies => [
+                { :text => 'third' }
+              ]
+            }
+          ]
+        },
+      ]
+      subject.format_tree(list).should == <<-TREE
+└─┬ first
+  └─┬ second
+    └── third
+TREE
+    end
+
+    it 'should show connectors when deep dependencies are not on the last node of the top level' do
+      list = [
+        {
+          :text => 'first',
+          :dependencies => [
+            {
+              :text => 'second',
+              :dependencies => [
+                { :text => 'third' }
+              ]
+            }
+          ]
+        },
+        { :text => 'fourth' }
+      ]
+      subject.format_tree(list).should == <<-TREE
+├─┬ first
+│ └─┬ second
+│   └── third
+└── fourth
+TREE
+    end
+
+    it 'should show connectors when deep dependencies are not on the last node of any level' do
+      list = [
+        {
+          :text => 'first',
+          :dependencies => [
+            {
+              :text => 'second',
+              :dependencies => [
+                { :text => 'third' }
+              ]
+            },
+            { :text => 'fourth' }
+          ]
+        }
+      ]
+      subject.format_tree(list).should == <<-TREE
+└─┬ first
+  ├─┬ second
+  │ └── third
+  └── fourth
+TREE
+    end
+
+    it 'should show connectors in every case when deep dependencies are not on the last node' do
+      list = [
+        {
+          :text => 'first',
+          :dependencies => [
+            {
+              :text => 'second',
+              :dependencies => [
+                { :text => 'third' }
+              ]
+            },
+            { :text => 'fourth' }
+          ]
+        },
+        { :text => 'fifth' }
+      ]
+      subject.format_tree(list).should == <<-TREE
+├─┬ first
+│ ├─┬ second
+│ │ └── third
+│ └── fourth
+└── fifth
+TREE
+    end
+  end
 end

data/spec/unit/node/environment_spec.rb

@@ -207,6 +207,22 @@ describe Puppet::Node::Environment do
             @second => [Puppet::Module.new('foo', :environment => env, :path => modpath2)]
           }
         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'))
+          FileUtils.mkdir_p(File.join(@first, 'foo.bar'))
+          FileUtils.mkdir_p(File.join(@first, '-foo'))
+          FileUtils.mkdir_p(File.join(@first, 'foo-'))
+          FileUtils.mkdir_p(File.join(@first, 'foo--bar'))
+
+          env.modules_by_path[@first].collect{|mod| mod.name}.sort.should == %w{foo foo-bar foo2 foo_bar}
+        end
+
       end
 
       describe "#module_requirements" do
@@ -336,7 +352,6 @@ describe Puppet::Node::Environment do
 
         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
 

data/spec/unit/parser/ast/leaf_spec.rb

@@ -263,7 +263,7 @@ end
 
 describe Puppet::Parser::AST::Regex do
   before :each do
-    @scope = stub 'scope'
+    @scope = stub 'scope', :ephemeral_from => true
   end
 
   describe "when initializing" do
@@ -323,6 +323,21 @@ describe Puppet::Parser::AST::Regex do
     end
   end
 
+  it "should match undef to the empty string" do
+    regex = Puppet::Parser::AST::Regex.new(:value => "^$")
+    regex.evaluate_match(:undef, @scope).should be_true
+  end
+
+  it "should not match undef to a non-empty string" do
+    regex = Puppet::Parser::AST::Regex.new(:value => '\w')
+    regex.evaluate_match(:undef, @scope).should be_false
+  end
+
+  it "should match a string against a string" do
+    regex = Puppet::Parser::AST::Regex.new(:value => '\w')
+    regex.evaluate_match('foo', @scope).should be_true
+  end
+
   it "should return the regex source with to_s" do
     regex = stub 'regex'
     Regexp.stubs(:new).returns(regex)

data/spec/unit/parser/collector_spec.rb

@@ -1,11 +1,5 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
-
-begin
-  require 'sqlite3'
-rescue LoadError
-end
-
 require 'puppet/rails'
 require 'puppet/parser/collector'
 
@@ -267,7 +261,7 @@ describe Puppet::Parser::Collector, "when collecting virtual and catalog resourc
   end
 end
 
-describe Puppet::Parser::Collector, "when collecting exported resources", :if => (Puppet.features.rails? and defined? SQLite3) do
+describe Puppet::Parser::Collector, "when collecting exported resources", :if => can_use_scratch_database? do
   include PuppetSpec::Files
 
   before do
@@ -287,14 +281,10 @@ describe Puppet::Parser::Collector, "when collecting exported resources", :if =>
 
   context "with storeconfigs enabled" do
     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
       Puppet[:environment]  = "production"
       Puppet[:storeconfigs_backend] = "active_record"
-      Puppet::Rails.init
     end
 
     it "should return all matching resources from the current compile and mark them non-virtual and non-exported" do

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

@@ -1,154 +1,203 @@
 require 'puppet'
 require 'spec_helper'
+require 'puppet_spec/compiler'
 
 describe 'function for dynamically creating resources' do
+  include PuppetSpec::Compiler
 
-  def get_scope
-    @topscope = Puppet::Parser::Scope.new
-    # This is necessary so we don't try to use the compiler to discover our parent.
-    @topscope.parent = nil
+  before :each do
     @scope = Puppet::Parser::Scope.new
     @scope.compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("floppy", :environment => 'production'))
-    @scope.parent = @topscope
+    @topscope = @scope.compiler.topscope
     @compiler = @scope.compiler
-  end
-  before :each do
-    get_scope
+    @scope.parent = @topscope
     Puppet::Parser::Functions.function(:create_resources)
   end
 
   it "should exist" do
     Puppet::Parser::Functions.function(:create_resources).should == "function_create_resources"
   end
+
   it 'should require two or three arguments' do
-    lambda { @scope.function_create_resources(['foo']) }.should raise_error(ArgumentError, 'create_resources(): wrong number of arguments (1; must be 2 or 3)')
-    lambda { @scope.function_create_resources(['foo', 'bar', 'blah', 'baz']) }.should raise_error(ArgumentError, 'create_resources(): wrong number of arguments (4; must be 2 or 3)')
+    expect { @scope.function_create_resources(['foo']) }.should raise_error(ArgumentError, 'create_resources(): wrong number of arguments (1; must be 2 or 3)')
+    expect { @scope.function_create_resources(['foo', 'bar', 'blah', 'baz']) }.should raise_error(ArgumentError, 'create_resources(): wrong number of arguments (4; must be 2 or 3)')
   end
-  describe 'when creating native types' do
-    before :each do
-      Puppet[:code]='notify{test:}'
-      get_scope
-      @scope.resource=Puppet::Parser::Resource.new('class', 't', :scope => @scope)
+
+  describe 'when the caller does not supply a name parameter' do
+    it 'should set a default resource name equal to the resource title' do
+      Puppet::Parser::Resource.any_instance.expects(:set_parameter).with(:name, 'test').once
+      @scope.function_create_resources(['notify', {'test'=>{}}])
+    end
+  end
+
+  describe 'when the caller supplies a name parameter' do
+    it 'should set the resource name to the value provided' do
+      Puppet::Parser::Resource.any_instance.expects(:set_parameter).with(:name, 'user_supplied').once
+      Puppet::Parser::Resource.any_instance.expects(:set_parameter).with(:name, 'test').never
+      @scope.function_create_resources(['notify', {'test'=>{'name' => 'user_supplied'}}])
     end
+  end
+
+  describe 'when creating native types' do
     it 'empty hash should not cause resources to be added' do
-      @scope.function_create_resources(['file', {}])
-      @compiler.catalog.resources.size == 1
+      noop_catalog = compile_to_catalog("create_resources('file', {})")
+      empty_catalog = compile_to_catalog("")
+      noop_catalog.resources.size.should == empty_catalog.resources.size
     end
+
     it 'should be able to add' do
-      @scope.function_create_resources(['file', {'/etc/foo'=>{'ensure'=>'present'}}])
-      @compiler.catalog.resource(:file, "/etc/foo")['ensure'].should == 'present'
+      catalog = compile_to_catalog("create_resources('file', {'/etc/foo'=>{'ensure'=>'present'}})")
+      catalog.resource(:file, "/etc/foo")['ensure'].should == 'present'
     end
+
     it 'should accept multiple types' do
-      type_hash = {}
-      type_hash['foo'] = {'message' => 'one'}
-      type_hash['bar'] = {'message' => 'two'}
-      @scope.function_create_resources(['notify', type_hash])
-      @compiler.catalog.resource(:notify, "foo")['message'].should == 'one'
-      @compiler.catalog.resource(:notify, "bar")['message'].should == 'two'
+      catalog = compile_to_catalog("create_resources('notify', {'foo'=>{'message'=>'one'}, 'bar'=>{'message'=>'two'}})")
+      catalog.resource(:notify, "foo")['message'].should == 'one'
+      catalog.resource(:notify, "bar")['message'].should == 'two'
     end
+
     it 'should fail to add non-existing type' do
-      lambda { @scope.function_create_resources(['foo', {}]) }.should raise_error(ArgumentError, 'could not create resource of unknown type foo')
+      expect { @scope.function_create_resources(['create-resource-foo', {}]) }.should raise_error(ArgumentError, 'could not create resource of unknown type create-resource-foo')
     end
+
     it 'should be able to add edges' do
-      @scope.function_create_resources(['notify', {'foo'=>{'require' => 'Notify[test]'}}])
-      @scope.compiler.compile
-      rg = @scope.compiler.catalog.to_ral.relationship_graph
+      catalog = compile_to_catalog("notify { test: }\n create_resources('notify', {'foo'=>{'require'=>'Notify[test]'}})")
+      rg = catalog.to_ral.relationship_graph
       test  = rg.vertices.find { |v| v.title == 'test' }
       foo   = rg.vertices.find { |v| v.title == 'foo' }
       test.should be
       foo.should be
       rg.path_between(test,foo).should be
     end
+
     it 'should account for default values' do
-      @scope.function_create_resources(['file', {'/etc/foo'=>{'ensure'=>'present'}, '/etc/baz'=>{'group'=>'food'}}, {'group' => 'bar'}])
-      @compiler.catalog.resource(:file, "/etc/foo")['group'].should == 'bar'
-      @compiler.catalog.resource(:file, "/etc/baz")['group'].should == 'food'
+      catalog = compile_to_catalog("create_resources('file', {'/etc/foo'=>{'ensure'=>'present'}, '/etc/baz'=>{'group'=>'food'}}, {'group' => 'bar'})")
+      catalog.resource(:file, "/etc/foo")['group'].should == 'bar'
+      catalog.resource(:file, "/etc/baz")['group'].should == 'food'
     end
   end
   describe 'when dynamically creating resource types' do
-    before :each do 
-      Puppet[:code]=
-'define foo($one){notify{$name: message => $one}}
-notify{test:}
-'
-      get_scope
-      @scope.resource=Puppet::Parser::Resource.new('class', 't', :scope => @scope)
-      Puppet::Parser::Functions.function(:create_resources)
-    end
     it 'should be able to create defined resoure types' do
-      @scope.function_create_resources(['foo', {'blah'=>{'one'=>'two'}}])
-      # still have to compile for this to work...
-      # I am not sure if this constraint ruins the tests
-      @scope.compiler.compile
-      @compiler.catalog.resource(:notify, "blah")['message'].should == 'two'
+      catalog = compile_to_catalog(<<-MANIFEST)
+        define foocreateresource($one) {
+          notify { $name: message => $one }
+        }
+        
+        create_resources('foocreateresource', {'blah'=>{'one'=>'two'}})
+      MANIFEST
+      catalog.resource(:notify, "blah")['message'].should == 'two'
     end
+
     it 'should fail if defines are missing params' do
-      @scope.function_create_resources(['foo', {'blah'=>{}}])
-      lambda { @scope.compiler.compile }.should raise_error(Puppet::ParseError, 'Must pass one to Foo[blah] at line 1')
+      expect { 
+        compile_to_catalog(<<-MANIFEST)
+          define foocreateresource($one) {
+            notify { $name: message => $one }
+          }
+          
+          create_resources('foocreateresource', {'blah'=>{}})
+        MANIFEST
+      }.should raise_error(Puppet::Error, 'Must pass one to Foocreateresource[blah] at line 1 on node foonode')
     end
+
     it 'should be able to add multiple defines' do
-      hash = {}
-      hash['blah'] = {'one' => 'two'}
-      hash['blaz'] = {'one' => 'three'}
-      @scope.function_create_resources(['foo', hash])
-      # still have to compile for this to work...
-      # I am not sure if this constraint ruins the tests
-      @scope.compiler.compile
-      @compiler.catalog.resource(:notify, "blah")['message'].should == 'two'
-      @compiler.catalog.resource(:notify, "blaz")['message'].should == 'three'
+      catalog = compile_to_catalog(<<-MANIFEST)
+        define foocreateresource($one) {
+          notify { $name: message => $one }
+        }
+        
+        create_resources('foocreateresource', {'blah'=>{'one'=>'two'}, 'blaz'=>{'one'=>'three'}})
+      MANIFEST
+
+      catalog.resource(:notify, "blah")['message'].should == 'two'
+      catalog.resource(:notify, "blaz")['message'].should == 'three'
     end
+
     it 'should be able to add edges' do
-      @scope.function_create_resources(['foo', {'blah'=>{'one'=>'two', 'require' => 'Notify[test]'}}])
-      @scope.compiler.compile
-      rg = @scope.compiler.catalog.to_ral.relationship_graph
+      catalog = compile_to_catalog(<<-MANIFEST)
+        define foocreateresource($one) {
+          notify { $name: message => $one }
+        }
+
+        notify { test: }
+        
+        create_resources('foocreateresource', {'blah'=>{'one'=>'two', 'require' => 'Notify[test]'}})
+      MANIFEST
+
+      rg = catalog.to_ral.relationship_graph
       test = rg.vertices.find { |v| v.title == 'test' }
       blah = rg.vertices.find { |v| v.title == 'blah' }
       test.should be
       blah.should be
-      # (Yoda speak like we do)
       rg.path_between(test,blah).should be
-      @compiler.catalog.resource(:notify, "blah")['message'].should == 'two'
+      catalog.resource(:notify, "blah")['message'].should == 'two'
     end
+
     it 'should account for default values' do
-      @scope.function_create_resources(['foo', {'blah'=>{}}, {'one' => 'two'}])
-      @scope.compiler.compile
-      @compiler.catalog.resource(:notify, "blah")['message'].should == 'two'
+      catalog = compile_to_catalog(<<-MANIFEST)
+        define foocreateresource($one) {
+          notify { $name: message => $one }
+        }
+
+        create_resources('foocreateresource', {'blah'=>{}}, {'one' => 'two'})
+      MANIFEST
+
+      catalog.resource(:notify, "blah")['message'].should == 'two'
     end
   end
+
   describe 'when creating classes' do
-    before :each do
-      Puppet[:code]=
-'class bar($one){notify{test: message => $one}}
-notify{tester:}
-'
-      get_scope
-      @scope.resource=Puppet::Parser::Resource.new('class', 't', :scope => @scope)
-      Puppet::Parser::Functions.function(:create_resources)
-    end
     it 'should be able to create classes' do
-      @scope.function_create_resources(['class', {'bar'=>{'one'=>'two'}}])
-      @scope.compiler.compile
-      @compiler.catalog.resource(:notify, "test")['message'].should == 'two'
-      @compiler.catalog.resource(:class, "bar").should_not be_nil#['message'].should == 'two'
+      catalog = compile_to_catalog(<<-MANIFEST)
+        class bar($one) {
+          notify { test: message => $one }
+        }
+
+        create_resources('class', {'bar'=>{'one'=>'two'}})
+      MANIFEST
+
+      catalog.resource(:notify, "test")['message'].should == 'two'
+      catalog.resource(:class, "bar").should_not be_nil
     end
+
     it 'should fail to create non-existing classes' do
-      lambda { @scope.function_create_resources(['class', {'blah'=>{'one'=>'two'}}]) }.should raise_error(ArgumentError ,'could not find hostclass blah')
+      expect {
+        compile_to_catalog(<<-MANIFEST)
+          create_resources('class', {'blah'=>{'one'=>'two'}})
+        MANIFEST
+      }.should raise_error(Puppet::Error ,'could not find hostclass blah at line 1 on node foonode')
     end
+
     it 'should be able to add edges' do
-      @scope.function_create_resources(['class', {'bar'=>{'one'=>'two', 'require' => 'Notify[tester]'}}])
-      @scope.compiler.compile
-      rg = @scope.compiler.catalog.to_ral.relationship_graph
+      catalog = compile_to_catalog(<<-MANIFEST)
+        class bar($one) {
+          notify { test: message => $one }
+        }
+
+        notify { tester: }
+
+        create_resources('class', {'bar'=>{'one'=>'two', 'require' => 'Notify[tester]'}})
+      MANIFEST
+
+      rg = catalog.to_ral.relationship_graph
       test   = rg.vertices.find { |v| v.title == 'test' }
       tester = rg.vertices.find { |v| v.title == 'tester' }
       test.should be
       tester.should be
       rg.path_between(tester,test).should be
     end
+
     it 'should account for default values' do
-      @scope.function_create_resources(['class', {'bar'=>{}}, {'one' => 'two'}])
-      @scope.compiler.compile
-      @compiler.catalog.resource(:notify, "test")['message'].should == 'two'
-      @compiler.catalog.resource(:class, "bar").should_not be_nil#['message'].should == 'two'
+      catalog = compile_to_catalog(<<-MANIFEST)
+        class bar($one) {
+          notify { test: message => $one }
+        }
+
+        create_resources('class', {'bar'=>{}}, {'one' => 'two'})
+      MANIFEST
+
+      catalog.resource(:notify, "test")['message'].should == 'two'
+      catalog.resource(:class, "bar").should_not be_nil
     end
   end
 end