puppet 3.3.2 → 3.4.0.rc1

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

@@ -0,0 +1,185 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet_spec/compiler'
+require 'puppet/parser/functions'
+require 'matchers/containment_matchers'
+require 'matchers/include_in_order'
+
+describe 'The "contain" function' do
+  include PuppetSpec::Compiler
+  include ContainmentMatchers
+
+  it "includes the class" do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      class contained {
+        notify { "contained": }
+      }
+
+      class container {
+        contain contained
+      }
+
+      include container
+    MANIFEST
+
+    expect(catalog.classes).to include("contained")
+  end
+
+  it "makes the class contained in the current class" do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      class contained {
+        notify { "contained": }
+      }
+
+      class container {
+        contain contained
+      }
+
+      include container
+    MANIFEST
+
+    expect(catalog).to contain_class("contained").in("container")
+  end
+
+  it "can contain multiple classes" do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      class a {
+        notify { "a": }
+      }
+
+      class b {
+        notify { "b": }
+      }
+
+      class container {
+        contain a, b
+      }
+
+      include container
+    MANIFEST
+
+    expect(catalog).to contain_class("a").in("container")
+    expect(catalog).to contain_class("b").in("container")
+  end
+
+  context "when containing a class in multiple classes" do
+    it "creates a catalog with all containment edges" do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        class contained {
+          notify { "contained": }
+        }
+
+        class container {
+          contain contained
+        }
+
+        class another {
+          contain contained
+        }
+
+        include container
+        include another
+      MANIFEST
+
+      expect(catalog).to contain_class("contained").in("container")
+      expect(catalog).to contain_class("contained").in("another")
+    end
+
+    it "and there are no dependencies applies successfully" do
+      manifest = <<-MANIFEST
+        class contained {
+          notify { "contained": }
+        }
+
+        class container {
+          contain contained
+        }
+
+        class another {
+          contain contained
+        }
+
+        include container
+        include another
+      MANIFEST
+
+      expect { apply_compiled_manifest(manifest) }.not_to raise_error
+    end
+
+    it "and there are explicit dependencies on the containing class causes a dependency cycle" do
+      manifest = <<-MANIFEST
+        class contained {
+          notify { "contained": }
+        }
+
+        class container {
+          contain contained
+        }
+
+        class another {
+          contain contained
+        }
+
+        include container
+        include another
+
+        Class["container"] -> Class["another"]
+      MANIFEST
+
+      expect { apply_compiled_manifest(manifest) }.to raise_error(
+        Puppet::Error,
+        /Found 1 dependency cycle/
+      )
+    end
+  end
+
+  it "does not create duplicate edges" do
+    catalog = compile_to_catalog(<<-MANIFEST)
+      class contained {
+        notify { "contained": }
+      }
+
+      class container {
+        contain contained
+        contain contained
+      }
+
+      include container
+    MANIFEST
+
+    contained = catalog.resource("Class", "contained")
+    container = catalog.resource("Class", "container")
+
+    expect(catalog.edges_between(container, contained)).to have(1).item
+  end
+
+  context "when a containing class has a dependency order" do
+    it "the contained class is applied in that order" do
+      catalog = compile_to_relationship_graph(<<-MANIFEST)
+        class contained {
+          notify { "contained": }
+        }
+
+        class container {
+          contain contained
+        }
+
+        class first {
+          notify { "first": }
+        }
+
+        class last {
+          notify { "last": }
+        }
+
+        include container, first, last
+
+        Class["first"] -> Class["container"] -> Class["last"]
+      MANIFEST
+
+      expect(order_resources_traversed_in(catalog)).to include_in_order(
+        "Notify[first]", "Notify[contained]", "Notify[last]"
+      )
+    end
+  end
+end

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

@@ -23,6 +23,14 @@ describe 'function for dynamically creating resources' do
     expect { @scope.function_create_resources(['foo', 'bar', 'blah', 'baz']) }.to raise_error(ArgumentError, 'create_resources(): wrong number of arguments (4; must be 2 or 3)')
   end
 
+  it 'should require second argument to be a hash' do
+    expect { @scope.function_create_resources(['foo','bar']) }.to raise_error(ArgumentError, 'create_resources(): second argument must be a hash')
+  end
+
+  it 'should require optional third argument to be a hash' do
+    expect { @scope.function_create_resources(['foo',{},'foo']) }.to raise_error(ArgumentError, 'create_resources(): third argument, if provided, must be a hash')
+  end
+
   describe 'when creating native types' do
     it 'empty hash should not cause resources to be added' do
       noop_catalog = compile_to_catalog("create_resources('file', {})")
@@ -75,12 +83,12 @@ describe 'function for dynamically creating resources' do
   end
 
   describe 'when dynamically creating resource types' do
-    it 'should be able to create defined resoure types' do
+    it 'should be able to create defined resource types' do
       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'
@@ -92,7 +100,7 @@ describe 'function for dynamically creating resources' do
           define foocreateresource($one) {
             notify { $name: message => $one }
           }
-          
+
           create_resources('foocreateresource', {'blah'=>{}})
         MANIFEST
       }.to raise_error(Puppet::Error, 'Must pass one to Foocreateresource[blah] on node foonode')
@@ -103,7 +111,7 @@ describe 'function for dynamically creating resources' do
         define foocreateresource($one) {
           notify { $name: message => $one }
         }
-        
+
         create_resources('foocreateresource', {'blah'=>{'one'=>'two'}, 'blaz'=>{'one'=>'three'}})
       MANIFEST
 
@@ -118,7 +126,7 @@ describe 'function for dynamically creating resources' do
         }
 
         notify { test: }
-        
+
         create_resources('foocreateresource', {'blah'=>{'one'=>'two', 'require' => 'Notify[test]'}})
       MANIFEST
 

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

@@ -45,7 +45,7 @@ describe "the generate function" do
     scope.function_generate([command]).should == 'yay'
   end
 
-  describe "on Windows", :as_platform => :windows do
+  describe "on Windows", :if => Puppet.features.microsoft_windows? do
     it "should accept the tilde in the path" do
       command = "C:/DOCUME~1/ADMINI~1/foo.bat"
       Dir.expects(:chdir).with(File.dirname(command)).returns("yay")

data/spec/unit/parser/functions_spec.rb

@@ -128,7 +128,7 @@ describe Puppet::Parser::Functions do
 
   describe "::get_function" do
     it "can retrieve a function defined on the *root* environment" do
-      Thread.current[:environment] = nil
+      $environment = nil
       function = Puppet::Parser::Functions.newfunction("atest", :type => :rvalue) do
         nil
       end
@@ -162,7 +162,7 @@ describe Puppet::Parser::Functions do
 
   describe "::merged_functions" do
     it "returns functions in both the current and root environment" do
-      Thread.current[:environment] = nil
+      $environment = nil
       func_a = Puppet::Parser::Functions.newfunction("test_a", :type => :rvalue) do
         nil
       end

data/spec/unit/parser/lexer_spec.rb

@@ -861,7 +861,7 @@ describe "when trying to lex a non-existent file" do
   it "should return an empty list of tokens" do
     lexer = Puppet::Parser::Lexer.new
     lexer.file = nofile = tmpfile('lexer')
-    File.exists?(nofile).should == false
+    Puppet::FileSystem::File.exist?(nofile).should == false
 
     lexer.fullscan.should == [[false,false]]
   end

data/spec/unit/parser/methods/each_spec.rb

@@ -26,7 +26,7 @@ describe 'the each method' do
     it 'each on an array selecting each value - function call style' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = [1,2,3]
-        each ($a) |$index, $v| => {
+        each ($a) |$index, $v| {
           file { "/file_$v": ensure => present }
         }
       MANIFEST

data/spec/unit/parser/methods/{select_spec.rb → filter_spec.rb}

@@ -4,17 +4,17 @@ require 'puppet_spec/compiler'
 
 require 'unit/parser/methods/shared'
 
-describe 'the select method' do
+describe 'the filter method' do
   include PuppetSpec::Compiler
 
   before :each do
     Puppet[:parser] = 'future'
   end
 
-  it 'should select on an array (all berries)' do
+  it 'should filter on an array (all berries)' do
     catalog = compile_to_catalog(<<-MANIFEST)
       $a = ['strawberry','blueberry','orange']
-      $a.select {|$x| $x  =~ /berry$/}.foreach {|$v|
+      $a.filter |$x|{ $x  =~ /berry$/}.each |$v|{
         file { "/file_$v": ensure => present }
       }
     MANIFEST
@@ -26,7 +26,7 @@ describe 'the select method' do
   it 'should produce an array when acting on an array' do
     catalog = compile_to_catalog(<<-MANIFEST)
       $a = ['strawberry','blueberry','orange']
-      $b = $a.select {|$x| $x  =~ /berry$/}
+      $b = $a.filter |$x|{ $x  =~ /berry$/}
       file { "/file_${b[0]}": ensure => present }
       file { "/file_${b[1]}": ensure => present }
     MANIFEST
@@ -35,10 +35,10 @@ describe 'the select method' do
     catalog.resource(:file, "/file_blueberry")['ensure'].should == 'present'
   end
 
-  it 'selects on a hash (all berries) by key' do
+  it 'filters on a hash (all berries) by key' do
     catalog = compile_to_catalog(<<-MANIFEST)
       $a = {'strawberry'=>'red','blueberry'=>'blue','orange'=>'orange'}
-      $a.select {|$x| $x[0]  =~ /berry$/}.foreach {|$v|
+      $a.filter |$x|{ $x[0]  =~ /berry$/}.each |$v|{
         file { "/file_${v[0]}": ensure => present }
       }
     MANIFEST
@@ -50,7 +50,7 @@ describe 'the select method' do
   it 'should produce a hash when acting on a hash' do
     catalog = compile_to_catalog(<<-MANIFEST)
       $a = {'strawberry'=>'red','blueberry'=>'blue','orange'=>'orange'}
-      $b = $a.select {|$x| $x[0]  =~ /berry$/}
+      $b = $a.filter |$x|{ $x[0]  =~ /berry$/}
       file { "/file_${b['strawberry']}": ensure => present }
       file { "/file_${b['blueberry']}": ensure => present }
       file { "/file_${b['orange']}": ensure => present }
@@ -62,10 +62,10 @@ describe 'the select method' do
     catalog.resource(:file, "/file_")['ensure'].should == 'present'
   end
 
-  it 'selects on a hash (all berries) by value' do
+  it 'filters on a hash (all berries) by value' do
     catalog = compile_to_catalog(<<-MANIFEST)
       $a = {'strawb'=>'red berry','blueb'=>'blue berry','orange'=>'orange fruit'}
-      $a.select {|$x| $x[1]  =~ /berry$/}.foreach {|$v|
+      $a.filter |$x|{ $x[1]  =~ /berry$/}.each |$v|{
         file { "/file_${v[0]}": ensure => present }
       }
     MANIFEST
@@ -74,6 +74,6 @@ describe 'the select method' do
     catalog.resource(:file, "/file_blueb")['ensure'].should == 'present'
   end
 
-  it_should_behave_like 'all iterative functions argument checks', 'select'
-  it_should_behave_like 'all iterative functions hash handling', 'select'
+  it_should_behave_like 'all iterative functions argument checks', 'filter'
+  it_should_behave_like 'all iterative functions hash handling', 'filter'
 end

data/spec/unit/parser/methods/map_spec.rb

@@ -0,0 +1,95 @@
+require 'puppet'
+require 'spec_helper'
+require 'puppet_spec/compiler'
+
+require 'unit/parser/methods/shared'
+
+describe 'the map method' do
+  include PuppetSpec::Compiler
+
+  before :each do
+    Puppet[:parser] = "future"
+  end
+
+  context "using future parser" do
+    it 'map on an array (multiplying each value by 2)' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1,2,3]
+        $a.map |$x|{ $x*2}.each |$v|{
+          file { "/file_$v": ensure => present }
+        }
+      MANIFEST
+
+      catalog.resource(:file, "/file_2")['ensure'].should == 'present'
+      catalog.resource(:file, "/file_4")['ensure'].should == 'present'
+      catalog.resource(:file, "/file_6")['ensure'].should == 'present'
+    end
+
+    it 'map on a hash selecting keys' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+      $a = {'a'=>1,'b'=>2,'c'=>3}
+      $a.map |$x|{ $x[0]}.each |$k|{
+          file { "/file_$k": ensure => present }
+        }
+      MANIFEST
+
+      catalog.resource(:file, "/file_a")['ensure'].should == 'present'
+      catalog.resource(:file, "/file_b")['ensure'].should == 'present'
+      catalog.resource(:file, "/file_c")['ensure'].should == 'present'
+    end
+
+    it 'each on a hash selecting value' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+      $a = {'a'=>1,'b'=>2,'c'=>3}
+      $a.map |$x|{ $x[1]}.each |$k|{
+          file { "/file_$k": ensure => present }
+        }
+      MANIFEST
+
+      catalog.resource(:file, "/file_1")['ensure'].should == 'present'
+      catalog.resource(:file, "/file_2")['ensure'].should == 'present'
+      catalog.resource(:file, "/file_3")['ensure'].should == 'present'
+    end
+
+    context "handles data type corner cases" do
+      it "map gets values that are false" do
+        catalog = compile_to_catalog(<<-MANIFEST)
+          $a = [false,false]
+          $a.map |$x| { $x }.each |$i, $v| {
+            file { "/file_$i.$v": ensure => present }
+          }
+        MANIFEST
+
+        catalog.resource(:file, "/file_0.false")['ensure'].should == 'present'
+        catalog.resource(:file, "/file_1.false")['ensure'].should == 'present'
+      end
+
+      it "map gets values that are nil" do
+        Puppet::Parser::Functions.newfunction(:nil_array, :type => :rvalue) do |args|
+          [nil]
+        end
+        catalog = compile_to_catalog(<<-MANIFEST)
+          $a = nil_array()
+          $a.map |$x| { $x }.each |$i, $v| {
+            file { "/file_$i.$v": ensure => present }
+          }
+        MANIFEST
+
+        catalog.resource(:file, "/file_0.")['ensure'].should == 'present'
+      end
+
+      it "map gets values that are undef" do
+        catalog = compile_to_catalog(<<-MANIFEST)
+          $a = [$does_not_exist]
+          $a.map |$x = "something"| { $x }.each |$i, $v| {
+            file { "/file_$i.$v": ensure => present }
+          }
+        MANIFEST
+
+        catalog.resource(:file, "/file_0.")['ensure'].should == 'present'
+      end
+    end
+  it_should_behave_like 'all iterative functions argument checks', 'map'
+  it_should_behave_like 'all iterative functions hash handling', 'map'
+  end
+end