puppet 3.7.3-x64-mingw32 → 3.7.4-x64-mingw32

data/spec/integration/parser/collector_spec.rb

@@ -68,6 +68,35 @@ describe Puppet::Parser::Collector do
       MANIFEST
     end
 
+    it "matches with bare word" do
+      expect_the_message_to_be(["wanted"], <<-MANIFEST)
+        @notify { "testing": tag => ["one"], message => "wanted" }
+        Notify <| tag == one |>
+      MANIFEST
+    end
+
+    it "matches with single quoted string" do
+      expect_the_message_to_be(["wanted"], <<-MANIFEST)
+        @notify { "testing": tag => ["one"], message => "wanted" }
+        Notify <| tag == 'one' |>
+      MANIFEST
+    end
+
+    it "matches with double quoted string" do
+      expect_the_message_to_be(["wanted"], <<-MANIFEST)
+        @notify { "testing": tag => ["one"], message => "wanted" }
+        Notify <| tag == "one" |>
+      MANIFEST
+    end
+
+    it "matches with double quoted string with interpolated expression" do
+      expect_the_message_to_be(["wanted"], <<-MANIFEST)
+        @notify { "testing": tag => ["one"], message => "wanted" }
+        $x = 'one'
+        Notify <| tag == "$x" |>
+      MANIFEST
+    end
+
     it "allows criteria to be combined with 'and'" do
       expect_the_message_to_be(["the message"], <<-MANIFEST)
         @notify { "testing": message => "the message" }
@@ -154,6 +183,18 @@ describe Puppet::Parser::Collector do
       end.to raise_error(/Classes cannot be collected/)
     end
 
+    it "does not collect resources that don't exist" do
+      node = Puppet::Node.new('the node')
+      expect do
+        catalog = compile_to_catalog(<<-MANIFEST, node)
+          class theclass {
+            @notify { "testing": message => "good message" }
+          }
+          SomeResource <|  |>
+        MANIFEST
+      end.to raise_error(/Resource type someresource doesn't exist/)
+    end
+
     context "overrides" do
       it "modifies an existing array" do
         expect_the_message_to_be([["original message", "extra message"]], <<-MANIFEST)

data/spec/integration/parser/compiler_spec.rb

@@ -522,4 +522,20 @@ describe "Puppet::Parser::Compiler" do
       expect(catalog).to have_resource("Notify[nbr2]").with_parameter(:message, 'overridden')
     end
   end
+
+
+  context "when converting catalog to resource" do
+    it "the same environment is used for compilation as for transformation to resource form" do
+        Puppet[:code] = <<-MANIFEST
+          notify { 'dummy':
+          }
+        MANIFEST
+
+      Puppet::Parser::Resource::Catalog.any_instance.expects(:to_resource).with do |catalog|
+        Puppet.lookup(:current_environment).name == :production
+      end
+
+      Puppet::Parser::Compiler.compile(Puppet::Node.new("mynode"))
+    end
+  end
 end

data/spec/integration/parser/future_compiler_spec.rb

@@ -270,7 +270,7 @@ describe "Puppet::Parser::Compiler" do
       end
 
       it "between collection expressions" do
-        assert_creates_relationships("File <| mode == 0644 |> -> File <| mode == 0755 |>",
+        assert_creates_relationships("File <| mode == '0644' |> -> File <| mode == '0755' |>",
                                      :relationships => [['a', 'd'],
                                                         ['b', 'd'],
                                                         ['c', 'd'],

data/spec/unit/environments_spec.rb

@@ -2,6 +2,7 @@ require 'spec_helper'
 require 'puppet/environments'
 require 'puppet/file_system'
 require 'matchers/include'
+require 'matchers/include_in_order'
 
 module PuppetEnvironments
 describe Puppet::Environments do
@@ -9,55 +10,50 @@ describe Puppet::Environments do
 
   FS = Puppet::FileSystem
 
-  describe "directories loader" do
-    before(:each) do
-      Puppet.settings.initialize_global_settings
-    end
+  before(:each) do
+    Puppet.settings.initialize_global_settings
+    Puppet[:environment_timeout] = "unlimited"
+  end
+
+  let(:directory_tree) do
+    FS::MemoryFile.a_directory(File.expand_path("envdir"), [
+      FS::MemoryFile.a_regular_file_containing("ignored_file", ''),
+      FS::MemoryFile.a_directory("an_environment", [
+        FS::MemoryFile.a_missing_file("environment.conf"),
+        FS::MemoryFile.a_directory("modules"),
+        FS::MemoryFile.a_directory("manifests"),
+      ]),
+      FS::MemoryFile.a_directory("another_environment", [
+        FS::MemoryFile.a_missing_file("environment.conf"),
+      ]),
+      FS::MemoryFile.a_missing_file("doesnotexist"),
+    ])
+  end
 
+  describe "directories loader" do
     it "lists environments" do
       global_path_1_location = File.expand_path("global_path_1")
       global_path_2_location = File.expand_path("global_path_2")
       global_path_1 = FS::MemoryFile.a_directory(global_path_1_location)
       global_path_2 = FS::MemoryFile.a_directory(global_path_2_location)
 
-      envdir = FS::MemoryFile.a_directory(File.expand_path("envdir"), [
-        FS::MemoryFile.a_directory("env1", [
-          FS::MemoryFile.a_missing_file("environment.conf"),
-          FS::MemoryFile.a_directory("modules"),
-          FS::MemoryFile.a_directory("manifests"),
-        ]),
-        FS::MemoryFile.a_directory("env2", [
-          FS::MemoryFile.a_missing_file("environment.conf"),
-        ]),
-      ])
-
-      loader_from(:filesystem => [envdir, global_path_1, global_path_2],
-                  :directory => envdir,
+      loader_from(:filesystem => [directory_tree, global_path_1, global_path_2],
+                  :directory => directory_tree,
                   :modulepath => [global_path_1_location, global_path_2_location]) do |loader|
         expect(loader.list).to include_in_any_order(
-          environment(:env1).
-            with_manifest("#{FS.path_string(envdir)}/env1/manifests").
-            with_modulepath(["#{FS.path_string(envdir)}/env1/modules",
+          environment(:an_environment).
+            with_manifest("#{FS.path_string(directory_tree)}/an_environment/manifests").
+            with_modulepath(["#{FS.path_string(directory_tree)}/an_environment/modules",
                              global_path_1_location,
                              global_path_2_location]),
-          environment(:env2))
+          environment(:another_environment))
       end
     end
 
-    it "does not list files" do
-      envdir = FS::MemoryFile.a_directory(File.expand_path("envdir"), [
-        FS::MemoryFile.a_regular_file_containing("foo", ''),
-        FS::MemoryFile.a_directory("env1", [
-          FS::MemoryFile.a_missing_file("environment.conf"),
-        ]),
-        FS::MemoryFile.a_directory("env2", [
-          FS::MemoryFile.a_missing_file("environment.conf"),
-        ]),
-      ])
-
-      loader_from(:filesystem => [envdir],
-                  :directory => envdir) do |loader|
-        expect(loader.list).to include_in_any_order(environment(:env1), environment(:env2))
+    it "has search_paths" do
+      loader_from(:filesystem => [directory_tree],
+                  :directory => directory_tree) do |loader|
+        expect(loader.search_paths).to eq(["file://#{directory_tree}"])
       end
     end
 
@@ -82,49 +78,25 @@ describe Puppet::Environments do
     end
 
     it "gets a particular environment" do
-      directory_tree = FS::MemoryFile.a_directory(File.expand_path("envdir"), [
-        FS::MemoryFile.a_directory("env1", [
-          FS::MemoryFile.a_missing_file("environment.conf"),
-        ]),
-        FS::MemoryFile.a_directory("env2", [
-          FS::MemoryFile.a_missing_file("environment.conf"),
-        ]),
-      ])
-
       loader_from(:filesystem => [directory_tree],
                   :directory => directory_tree) do |loader|
-        expect(loader.get("env1")).to environment(:env1)
+        expect(loader.get("an_environment")).to environment(:an_environment)
       end
     end
 
     it "raises error when environment not found" do
-      directory_tree = FS::MemoryFile.a_directory(File.expand_path("envdir"), [])
-
       loader_from(:filesystem => [directory_tree],
                   :directory => directory_tree) do |loader|
         expect do
-          loader.get!("does_not_exist")
+          loader.get!("doesnotexist")
         end.to raise_error(Puppet::Environments::EnvironmentNotFound)
       end
     end
 
     it "returns nil if an environment can't be found" do
-      directory_tree = FS::MemoryFile.a_directory("envdir", [])
-
       loader_from(:filesystem => [directory_tree],
                   :directory => directory_tree) do |loader|
-        expect(loader.get("env_not_in_this_list")).to be_nil
-      end
-    end
-
-    it "raises error if an environment can't be found" do
-      directory_tree = FS::MemoryFile.a_directory("envdir", [])
-
-      loader_from(:filesystem => [directory_tree],
-                  :directory => directory_tree) do |loader|
-        expect do
-          loader.get!("env_not_in_this_list")
-        end.to raise_error(Puppet::Environments::EnvironmentNotFound)
+        expect(loader.get("doesnotexist")).to be_nil
       end
     end
 
@@ -362,53 +334,19 @@ config_version=$vardir/random/scripts
       end
 
       context "custom cache expiration service" do
-        let(:envs_created) { Set.new }
-        let(:envs_expired) { Set.new }
-        let(:envs_evicted) { Set.new }
-
-        it "should support registering a custom cache expiration service" do
-
-          class CustomExpirationService
-            def initialize(envs_created, envs_expired, envs_evicted)
-              @envs_created = envs_created
-              @envs_expired = envs_expired
-              @envs_evicted = envs_evicted
-            end
-
-            def created(env)
-              @envs_created << env.name
-            end
-            def expired?(env_name)
-              @envs_expired << env_name
-              true
-            end
-            def evicted(env_name)
-              @envs_evicted << env_name
-            end
-          end
-
-          Puppet[:environment_timeout] = "unlimited"
-          directory_tree = FS::MemoryFile.a_directory(File.expand_path("envdir"), [
-              FS::MemoryFile.a_directory("static1", [
-                  FS::MemoryFile.a_missing_file("environment.conf"),
-              ]),
-          ])
-
+        it "consults the custom service to expire the cache" do
           loader_from(:filesystem => [directory_tree],
                       :directory => directory_tree) do |loader|
-            begin
-              orig_svc = Puppet::Environments::Cached.cache_expiration_service
-              Puppet::Environments::Cached.cache_expiration_service =
-                  CustomExpirationService.new(envs_created, envs_expired, envs_evicted)
+            service = ReplayExpirationService.new([true])
+            using_expiration_service(service) do
+
               cached = Puppet::Environments::Cached.new(loader)
-              cached.get(:static1)
-              cached.get(:static1)
-
-              expect(envs_created.include?(:static1)).to eq(true)
-              expect(envs_expired.include?(:static1)).to eq(true)
-              expect(envs_evicted.include?(:static1)).to eq(true)
-            ensure
-              Puppet::Environments::Cached.cache_expiration_service = orig_svc
+              cached.get(:an_environment)
+              cached.get(:an_environment)
+
+              expect(service.created_envs).to include(:an_environment)
+              expect(service.expired_envs).to include(:an_environment)
+              expect(service.evicted_envs).to include(:an_environment)
             end
           end
         end
@@ -425,6 +363,10 @@ config_version=$vardir/random/scripts
       expect(loader.list).to eq([static1, static2])
     end
 
+    it "has search_paths" do
+      expect(loader.search_paths).to eq(["data:text/plain,internal"])
+    end
+
     it "gets an environment" do
       expect(loader.get(:static2)).to eq(static2)
     end
@@ -460,25 +402,142 @@ config_version=$vardir/random/scripts
     end
   end
 
+  describe "combined loaders" do
+    let(:static1) { Puppet::Node::Environment.create(:static1, []) }
+    let(:static2) { Puppet::Node::Environment.create(:static2, []) }
+    let(:static_loader) { Puppet::Environments::Static.new(static1, static2) }
+    let(:directory_tree) do
+      FS::MemoryFile.a_directory(File.expand_path("envdir"), [
+        FS::MemoryFile.a_directory("an_environment", [
+          FS::MemoryFile.a_missing_file("environment.conf"),
+          FS::MemoryFile.a_directory("modules"),
+          FS::MemoryFile.a_directory("manifests"),
+        ]),
+        FS::MemoryFile.a_missing_file("env_does_not_exist"),
+        FS::MemoryFile.a_missing_file("static2"),
+      ])
+    end
 
-  describe "cached loaders" do
-    let(:cached1) { Puppet::Node::Environment.create(:cached1, []) }
-    let(:cached2) { Puppet::Node::Environment.create(:cached2, []) }
-    let(:static_loader) { Puppet::Environments::Static.new(cached1, cached2) }
-    let(:loader) { Puppet::Environments::Cached.new(static_loader) }
+    it "lists environments" do
+      loader_from(:filesystem => [directory_tree], :directory => directory_tree) do |loader|
+        envs = Puppet::Environments::Combined.new(loader, static_loader).list
+        expect(envs[0]).to environment(:an_environment)
+        expect(envs[1]).to environment(:static1)
+        expect(envs[2]).to environment(:static2)
+      end
+    end
+
+    it "has search_paths" do
+      loader_from(:filesystem => [directory_tree], :directory => directory_tree) do |loader|
+        expect(Puppet::Environments::Combined.new(loader, static_loader).search_paths).to eq(["file://#{directory_tree}","data:text/plain,internal"])
+      end
+    end
 
     it "gets an environment" do
-      expect(loader.get(:cached2)).to eq(cached2)
+      loader_from(:filesystem => [directory_tree], :directory => directory_tree) do |loader|
+        expect(Puppet::Environments::Combined.new(loader, static_loader).get(:an_environment)).to environment(:an_environment)
+        expect(Puppet::Environments::Combined.new(loader, static_loader).get(:static2)).to environment(:static2)
+      end
     end
 
     it "returns nil if env not found" do
-      expect(loader.get(:doesnotexist)).to be_nil
+      loader_from(:filesystem => [directory_tree], :directory => directory_tree) do |loader|
+        expect(Puppet::Environments::Combined.new(loader, static_loader).get(:env_does_not_exist)).to be_nil
+      end
     end
 
-    it "raises error if environment is not found" do
-      expect do
-        loader.get!(:doesnotexist)
-      end.to raise_error(Puppet::Environments::EnvironmentNotFound)
+    it "raises an error if environment is not found" do
+      loader_from(:filesystem => [directory_tree], :directory => directory_tree) do |loader|
+        expect do
+          Puppet::Environments::Combined.new(loader, static_loader).get!(:env_does_not_exist)
+        end.to raise_error(Puppet::Environments::EnvironmentNotFound)
+      end
+    end
+
+    it "gets an environment.conf" do
+      loader_from(:filesystem => [directory_tree], :directory => directory_tree) do |loader|
+        expect(Puppet::Environments::Combined.new(loader, static_loader).get_conf(:an_environment)).to match_environment_conf(:an_environment).
+          with_env_path(directory_tree).
+          with_global_module_path([])
+      end
+    end
+  end
+
+  describe "cached loaders" do
+    it "lists environments" do
+      loader_from(:filesystem => [directory_tree], :directory => directory_tree) do |loader|
+        expect(Puppet::Environments::Cached.new(loader).list).to include_in_any_order(
+          environment(:an_environment),
+          environment(:another_environment))
+      end
+    end
+
+    it "has search_paths" do
+      loader_from(:filesystem => [directory_tree], :directory => directory_tree) do |loader|
+        expect(Puppet::Environments::Cached.new(loader).search_paths).to eq(["file://#{directory_tree}"])
+      end
+    end
+
+    context "#get" do
+      it "gets an environment" do
+        loader_from(:filesystem => [directory_tree], :directory => directory_tree) do |loader|
+          expect(Puppet::Environments::Cached.new(loader).get(:an_environment)).to environment(:an_environment)
+        end
+      end
+
+      it "does not reload the environment if it isn't expired" do
+        env = Puppet::Node::Environment.create(:cached, [])
+        mocked_loader = mock('loader')
+        mocked_loader.expects(:get).with(:cached).returns(env).once
+        mocked_loader.expects(:get_conf).with(:cached).returns(Puppet::Settings::EnvironmentConf.static_for(env, 20)).once
+
+        cached = Puppet::Environments::Cached.new(mocked_loader)
+
+        cached.get(:cached)
+        cached.get(:cached)
+      end
+
+      it "returns nil if env not found" do
+        loader_from(:filesystem => [directory_tree], :directory => directory_tree) do |loader|
+          expect(Puppet::Environments::Cached.new(loader).get(:doesnotexist)).to be_nil
+        end
+      end
+    end
+
+    context "#get!" do
+      it "gets an environment" do
+        loader_from(:filesystem => [directory_tree], :directory => directory_tree) do |loader|
+          expect(Puppet::Environments::Cached.new(loader).get!(:an_environment)).to environment(:an_environment)
+        end
+      end
+
+      it "does not reload the environment if it isn't expired" do
+        env = Puppet::Node::Environment.create(:cached, [])
+        mocked_loader = mock('loader')
+        mocked_loader.expects(:get).with(:cached).returns(env).once
+        mocked_loader.expects(:get_conf).with(:cached).returns(Puppet::Settings::EnvironmentConf.static_for(env, 20)).once
+
+        cached = Puppet::Environments::Cached.new(mocked_loader)
+
+        cached.get!(:cached)
+        cached.get!(:cached)
+      end
+
+      it "raises error if environment is not found" do
+        loader_from(:filesystem => [directory_tree], :directory => directory_tree) do |loader|
+          expect do
+            Puppet::Environments::Cached.new(loader).get!(:doesnotexist)
+          end.to raise_error(Puppet::Environments::EnvironmentNotFound)
+        end
+      end
+    end
+
+    it "gets an environment.conf" do
+      loader_from(:filesystem => [directory_tree], :directory => directory_tree) do |loader|
+        expect(Puppet::Environments::Cached.new(loader).get_conf(:an_environment)).to match_environment_conf(:an_environment).
+          with_env_path(directory_tree).
+          with_global_module_path([])
+      end
     end
   end
 
@@ -516,7 +575,33 @@ config_version=$vardir/random/scripts
     end
 
     failure_message_for_should do |env|
-      "expected <#{env.name}: modulepath = [#{env.modulepath.join(', ')}], manifest = #{env.manifest}, config_version = #{env.config_version}> to be #{description}"
+      "expected <#{env.name}: modulepath = [#{env.full_modulepath.join(', ')}], manifest = #{env.manifest}, config_version = #{env.config_version}> to be #{description}"
+    end
+  end
+
+  RSpec::Matchers.define :match_environment_conf do |env_name|
+    match do |env_conf|
+      env_conf.path_to_env =~ /#{env_name}$/ &&
+        (!@env_path || File.join(@env_path,env_name.to_s) == env_conf.path_to_env) &&
+        (!@global_modulepath || @global_module_path == env_conf.global_module_path)
+    end
+
+    chain :with_env_path do |env_path|
+      @env_path = env_path.to_s
+    end
+
+    chain :with_global_module_path do |global_module_path|
+      @global_module_path = global_module_path
+    end
+
+    description do
+      "EnvironmentConf #{expected}" +
+        " with path_to_env: #{@env_path ? @env_path : "*"}/#{env_name}" +
+        (@global_module_path ? " with global_module_path [#{@global_module_path.join(', ')}]" : "")
+    end
+
+    failure_message_for_should do |env_conf|
+      "expected #{env_conf.inspect} to be #{description}"
     end
   end
 
@@ -531,5 +616,40 @@ config_version=$vardir/random/scripts
       end
     end
   end
+
+  def using_expiration_service(service)
+    begin
+      orig_svc = Puppet::Environments::Cached.cache_expiration_service
+      Puppet::Environments::Cached.cache_expiration_service = service
+      yield
+    ensure
+      Puppet::Environments::Cached.cache_expiration_service = orig_svc
+    end
+  end
+
+  class ReplayExpirationService
+    attr_reader :created_envs, :expired_envs, :evicted_envs
+
+    def initialize(expiration_sequence)
+      @created_envs = []
+      @expired_envs = []
+      @evicted_envs = []
+      @expiration_sequence = expiration_sequence
+    end
+
+    def created(env)
+      @created_envs << env.name
+    end
+
+    def expired?(env_name)
+      @expired_envs << env_name
+      @expiration_sequence.pop
+    end
+
+    def evicted(env_name)
+      @evicted_envs << env_name
+    end
+  end
+
 end
 end