puppet 3.5.1-x86-mingw32 → 3.6.0.rc1-x86-mingw32

data/spec/shared_contexts/checksums.rb

@@ -0,0 +1,55 @@
+# Shared contexts for testing against all supported digest algorithms.
+#
+# These helpers define nested rspec example groups to test code against all our
+# supported digest algorithms. Example groups that need to be run against all
+# algorithms should use the `using_checksums_describe` helper which will
+# create a new example group for each algorithm and will run the given block
+# in each example group.
+#
+# For each algorithm a shared context is defined for the given algorithm that
+# has precomputed checksum values and paths. These contexts are included
+# automatically based on the rspec metadata selected with
+# `using_checksums_describe`.
+
+DIGEST_ALGORITHMS_TO_TRY = ['md5', 'sha256']
+
+shared_context('with supported digest algorithms', :uses_checksums => true) do
+
+  def self.with_digest_algorithms(&block)
+    DIGEST_ALGORITHMS_TO_TRY.each do |digest_algorithm|
+      describe("when digest_algorithm is #{digest_algorithm}", :digest_algorithm => digest_algorithm) do
+        instance_eval(&block)
+      end
+    end
+  end
+end
+
+shared_context("when digest_algorithm is set to sha256", :digest_algorithm => 'sha256') do
+  before { Puppet[:digest_algorithm] = 'sha256' }
+  after { Puppet[:digest_algorithm] = nil }
+
+  let(:digest_algorithm) { 'sha256' }
+
+  let(:plaintext) { "my\r\ncontents" }
+  let(:checksum) { '409a11465ed0938227128b1756c677a8480a8b84814f1963853775e15a74d4b4' }
+  let(:bucket_dir) { '4/0/9/a/1/1/4/6/409a11465ed0938227128b1756c677a8480a8b84814f1963853775e15a74d4b4' }
+
+  def digest(content)
+    Puppet::Util::Checksums.sha256(content)
+  end
+end
+
+shared_context("when digest_algorithm is set to md5", :digest_algorithm => 'md5') do
+  before { Puppet[:digest_algorithm] = 'md5' }
+  after { Puppet[:digest_algorithm] = nil }
+
+  let(:digest_algorithm) { 'md5' }
+
+  let(:plaintext) { "my\r\ncontents" }
+  let(:checksum) { 'f0d7d4e480ad698ed56aeec8b6bd6dea' }
+  let(:bucket_dir) { 'f/0/d/7/d/4/e/4/f0d7d4e480ad698ed56aeec8b6bd6dea' }
+
+  def digest(content)
+    Puppet::Util::Checksums.md5(content)
+  end
+end

data/spec/unit/application/apply_spec.rb

@@ -180,7 +180,7 @@ describe Puppet::Application::Apply do
         @node = Puppet::Node.new(Puppet[:node_name_value])
         Puppet::Node.indirection.save(@node)
 
-        @catalog = Puppet::Resource::Catalog.new
+        @catalog = Puppet::Resource::Catalog.new("testing", Puppet.lookup(:environments).get(Puppet[:environment]))
         @catalog.stubs(:to_ral).returns(@catalog)
 
         Puppet::Resource::Catalog.indirection.stubs(:find).returns(@catalog)
@@ -397,22 +397,24 @@ describe Puppet::Application::Apply do
 
       it "should read the catalog in from disk if a file name is provided" do
         @apply.options[:catalog] = temporary_catalog
-        Puppet::Resource::Catalog.stubs(:convert_from).
-          with(:pson,'"something"').returns(Puppet::Resource::Catalog.new)
+        catalog = Puppet::Resource::Catalog.new("testing", Puppet::Node::Environment::NONE)
+        Puppet::Resource::Catalog.stubs(:convert_from).with(:pson,'"something"').returns(catalog)
         @apply.apply
       end
 
       it "should read the catalog in from stdin if '-' is provided" do
         @apply.options[:catalog] = "-"
         $stdin.expects(:read).returns '"something"'
-        Puppet::Resource::Catalog.stubs(:convert_from).with(:pson,'"something"').returns Puppet::Resource::Catalog.new
+        catalog = Puppet::Resource::Catalog.new("testing", Puppet::Node::Environment::NONE)
+        Puppet::Resource::Catalog.stubs(:convert_from).with(:pson,'"something"').returns(catalog)
         @apply.apply
       end
 
       it "should deserialize the catalog from the default format" do
         @apply.options[:catalog] = temporary_catalog
         Puppet::Resource::Catalog.stubs(:default_format).returns :rot13_piglatin
-        Puppet::Resource::Catalog.stubs(:convert_from).with(:rot13_piglatin,'"something"').returns Puppet::Resource::Catalog.new
+        catalog = Puppet::Resource::Catalog.new("testing", Puppet::Node::Environment::NONE)
+        Puppet::Resource::Catalog.stubs(:convert_from).with(:rot13_piglatin,'"something"').returns(catalog)
         @apply.apply
       end
 
@@ -424,13 +426,14 @@ describe Puppet::Application::Apply do
       it "should convert plain data structures into a catalog if deserialization does not do so" do
         @apply.options[:catalog] = temporary_catalog
         Puppet::Resource::Catalog.stubs(:convert_from).with(:pson,'"something"').returns({:foo => "bar"})
-        Puppet::Resource::Catalog.expects(:pson_create).with({:foo => "bar"}).returns(Puppet::Resource::Catalog.new)
+        catalog = Puppet::Resource::Catalog.new("testing", Puppet::Node::Environment::NONE)
+        Puppet::Resource::Catalog.expects(:pson_create).with({:foo => "bar"}).returns(catalog)
         @apply.apply
       end
 
       it "should convert the catalog to a RAL catalog and use a Configurer instance to apply it" do
         @apply.options[:catalog] = temporary_catalog
-        catalog = Puppet::Resource::Catalog.new
+        catalog = Puppet::Resource::Catalog.new("testing", Puppet::Node::Environment::NONE)
         Puppet::Resource::Catalog.stubs(:convert_from).with(:pson,'"something"').returns catalog
         catalog.expects(:to_ral).returns "mycatalog"
 

data/spec/unit/application/doc_spec.rb

@@ -255,17 +255,16 @@ describe Puppet::Application::Doc do
 
   describe "when running" do
     describe "in rdoc mode" do
-      let(:modules) { File.expand_path("modules") }
-      let(:manifests) { File.expand_path("manifests") }
+      include PuppetSpec::Files
+
+      let(:envdir) { tmpdir('env') }
+      let(:modules) { File.join(envdir, "modules") }
+      let(:manifests) { File.join(envdir, "manifests") }
 
       before :each do
         @doc.manifest = false
         Puppet.stubs(:info)
         Puppet[:trace] = false
-        @env = stub 'env'
-        @env.stubs(:modulepath).returns([modules])
-        @env.stubs(:[]).with(:manifest).returns('manifests/site.pp')
-        Puppet::Node::Environment.stubs(:new).returns(@env)
         Puppet[:modulepath] = modules
         Puppet[:manifestdir] = manifests
         @doc.options[:all] = false
@@ -276,6 +275,14 @@ describe Puppet::Application::Doc do
         @doc.command_line.stubs(:args).returns([])
       end
 
+      around(:each) do |example|
+        FileUtils.mkdir_p(modules)
+        @env = Puppet::Node::Environment.create(Puppet[:environment].to_sym, [modules], "#{manifests}/site.pp")
+        Puppet.override(:environments => Puppet::Environments::Static.new(@env)) do
+          example.run
+        end
+      end
+
       it "should set document_all on --all" do
         @doc.options[:all] = true
         Puppet.settings.expects(:[]=).with(:document_all, true)
@@ -284,19 +291,19 @@ describe Puppet::Application::Doc do
       end
 
       it "should call Puppet::Util::RDoc.rdoc in full mode" do
-        Puppet::Util::RDoc.expects(:rdoc).with('doc', [modules, 'manifests'], nil)
+        Puppet::Util::RDoc.expects(:rdoc).with('doc', [modules, manifests], nil)
         expect { @doc.rdoc }.to exit_with 0
       end
 
       it "should call Puppet::Util::RDoc.rdoc with a charset if --charset has been provided" do
         @doc.options[:charset] = 'utf-8'
-        Puppet::Util::RDoc.expects(:rdoc).with('doc', [modules, 'manifests'], "utf-8")
+        Puppet::Util::RDoc.expects(:rdoc).with('doc', [modules, manifests], "utf-8")
         expect { @doc.rdoc }.to exit_with 0
       end
 
       it "should call Puppet::Util::RDoc.rdoc in full mode with outputdir set to doc if no --outputdir" do
         @doc.options[:outputdir] = false
-        Puppet::Util::RDoc.expects(:rdoc).with('doc', [modules, 'manifests'], nil)
+        Puppet::Util::RDoc.expects(:rdoc).with('doc', [modules, manifests], nil)
         expect { @doc.rdoc }.to exit_with 0
       end
 
@@ -308,7 +315,7 @@ describe Puppet::Application::Doc do
 
       it "should get modulepath and manifestdir values from the environment" do
         @env.expects(:modulepath).returns(['envmodules1','envmodules2'])
-        @env.expects(:[]).with(:manifest).returns('envmanifests/site.pp')
+        @env.expects(:manifest).returns('envmanifests/site.pp')
 
         Puppet::Util::RDoc.expects(:rdoc).with('doc', ['envmodules1','envmodules2','envmanifests'], nil)
 

data/spec/unit/application/indirection_base_spec.rb

@@ -8,19 +8,27 @@ require 'puppet/indirector/face'
 # Stub for testing; the names are critical, sadly. --daniel 2011-03-30
 class Puppet::Application::TestIndirection < Puppet::Application::IndirectionBase
 end
-
-face = Puppet::Indirector::Face.define(:test_indirection, '0.0.1') do
-  summary "fake summary"
-  copyright "Puppet Labs", 2011
-  license   "Apache 2 license; see COPYING"
-end
-# REVISIT: This horror is required because we don't allow anything to be
-# :current except for if it lives on, and is loaded from, disk. --daniel 2011-03-29
-face.instance_variable_set('@version', :current)
-Puppet::Face.register(face)
 ########################################################################
 
 describe Puppet::Application::IndirectionBase do
+  before :all do
+    @face = Puppet::Indirector::Face.define(:test_indirection, '0.0.1') do
+      summary "fake summary"
+      copyright "Puppet Labs", 2011
+      license   "Apache 2 license; see COPYING"
+    end
+    # REVISIT: This horror is required because we don't allow anything to be
+    # :current except for if it lives on, and is loaded from, disk. --daniel 2011-03-29
+    @face.instance_variable_set('@version', :current)
+
+    Puppet::Face.register(@face)
+  end
+
+  after :all do
+    # Delete the face so that it doesn't interfere with other specs
+    Puppet::Interface::FaceCollection.instance_variable_get(:@faces).delete Puppet::Interface::FaceCollection.underscorize(@face.name)
+  end
+
   it "should accept a terminus command line option" do
     # It would be nice not to have to stub this, but whatever... writing an
     # entire indirection stack would cause us more grief. --daniel 2011-03-31

data/spec/unit/application/inspect_spec.rb

@@ -33,7 +33,7 @@ describe Puppet::Application::Inspect do
     end
   end
 
-  describe "when executing" do
+  describe "when executing", :uses_checksums => true do
     before :each do
       Puppet[:report] = true
       @inspect.options[:setdest] = true
@@ -54,30 +54,32 @@ describe Puppet::Application::Inspect do
       @inspect.run_command
     end
 
-    it "should audit the specified properties" do
-      catalog = Puppet::Resource::Catalog.new
-      file = Tempfile.new("foo")
-      file.binmode
-      file.puts("file contents")
-      file.close
-      resource = Puppet::Resource.new(:file, file.path, :parameters => {:audit => "all"})
-      catalog.add_resource(resource)
-      Puppet::Resource::Catalog::Yaml.any_instance.stubs(:find).returns(catalog)
+    with_digest_algorithms do
+      it "should audit the specified properties" do
+        catalog = Puppet::Resource::Catalog.new
+        file = Tempfile.new("foo")
+        file.binmode
+        file.print plaintext
+        file.close
+        resource = Puppet::Resource.new(:file, file.path, :parameters => {:audit => "all"})
+        catalog.add_resource(resource)
+        Puppet::Resource::Catalog::Yaml.any_instance.stubs(:find).returns(catalog)
 
-      events = nil
+        events = nil
 
-      Puppet::Transaction::Report::Rest.any_instance.expects(:save).with do |request|
-        events = request.instance.resource_statuses.values.first.events
-      end
+        Puppet::Transaction::Report::Rest.any_instance.expects(:save).with do |request|
+          events = request.instance.resource_statuses.values.first.events
+        end
 
-      @inspect.run_command
+        @inspect.run_command
 
-      properties = events.inject({}) do |property_values, event|
-        property_values.merge(event.property => event.previous_value)
+        properties = events.inject({}) do |property_values, event|
+          property_values.merge(event.property => event.previous_value)
+        end
+        properties["ensure"].should == :file
+        properties["content"].should == "{#{digest_algorithm}}#{checksum}"
+        properties.has_key?("target").should == false
       end
-      properties["ensure"].should == :file
-      properties["content"].should == "{md5}#{Digest::MD5.hexdigest("file contents\n")}"
-      properties.has_key?("target").should == false
     end
 
     it "should set audited to true for all events" do

data/spec/unit/configurer/downloader_spec.rb

@@ -51,6 +51,11 @@ describe Puppet::Configurer::Downloader do
       @dler.file
     end
 
+    it "should set source_permissions to ignore" do
+      Puppet::Type.type(:file).expects(:new).with { |opts| opts[:source_permissions] == :ignore }
+      @dler.file
+    end
+
     describe "on POSIX", :as_platform => :posix do
       it "should always set the owner to the current UID" do
         Process.expects(:uid).returns 51
@@ -75,11 +80,6 @@ describe Puppet::Configurer::Downloader do
         Puppet::Type.type(:file).expects(:new).with { |opts| opts[:group] == nil }
         @dler.file
       end
-
-      it "should set source_permissions to ignore" do
-        Puppet::Type.type(:file).expects(:new).with { |opts| opts[:source_permissions] == :ignore }
-        @dler.file
-      end
     end
 
     it "should always force the download" do
@@ -129,7 +129,8 @@ describe Puppet::Configurer::Downloader do
       @dl_name = tmpfile("downloadpath")
       source_name = tmpfile("source")
       File.open(source_name, 'w') {|f| f.write('hola mundo') }
-      @dler = Puppet::Configurer::Downloader.new("foo", @dl_name, source_name)
+      env = Puppet::Node::Environment.remote('foo')
+      @dler = Puppet::Configurer::Downloader.new("foo", @dl_name, source_name, Puppet[:pluginsignore], env)
     end
 
     it "should not skip downloaded resources when filtering on tags" do

data/spec/unit/configurer/plugin_handler_spec.rb

@@ -18,25 +18,22 @@ describe Puppet::Configurer::PluginHandler do
   end
 
   it "should use an Agent Downloader, with the name, source, destination, ignore, and environment set correctly, to download plugins when downloading is enabled" do
-    downloader = mock 'downloader'
+    environment = Puppet::Node::Environment.create(:myenv, [])
     Puppet.features.stubs(:external_facts?).returns(:true)
-    # This is needed in order to make sure we pass on windows
     plugindest = File.expand_path("/tmp/pdest")
-
     Puppet[:pluginsource] = "psource"
     Puppet[:plugindest] = plugindest
     Puppet[:pluginsignore] = "pignore"
-
     Puppet[:pluginfactsource] = "psource"
     Puppet[:pluginfactdest] = plugindest
 
-    Puppet::Configurer::Downloader.expects(:new).with("pluginfacts", plugindest, "psource", "pignore", "myenv").returns downloader
-    Puppet::Configurer::Downloader.expects(:new).with("plugin", plugindest, "psource", "pignore", "myenv").returns downloader
+    downloader = mock 'downloader'
+    Puppet::Configurer::Downloader.expects(:new).with("pluginfacts", plugindest, "psource", "pignore", environment).returns downloader
+    Puppet::Configurer::Downloader.expects(:new).with("plugin", plugindest, "psource", "pignore", environment).returns downloader
 
     downloader.stubs(:evaluate).returns([])
     downloader.expects(:evaluate).twice
 
-    @pluginhandler.environment = "myenv"
-    @pluginhandler.download_plugins
+    @pluginhandler.download_plugins(environment)
   end
 end

data/spec/unit/configurer_spec.rb

@@ -74,7 +74,7 @@ describe Puppet::Configurer do
       @facts = Puppet::Node::Facts.new(Puppet[:node_name_value])
       Puppet::Node::Facts.indirection.save(@facts)
 
-      @catalog = Puppet::Resource::Catalog.new
+      @catalog = Puppet::Resource::Catalog.new("tester", Puppet::Node::Environment.remote(Puppet[:environment].to_sym))
       @catalog.stubs(:to_ral).returns(@catalog)
       Puppet::Resource::Catalog.indirection.terminus_class = :rest
       Puppet::Resource::Catalog.indirection.stubs(:find).returns(@catalog)

data/spec/unit/context_spec.rb

@@ -71,4 +71,27 @@ describe Puppet::Context do
       expect(context.lookup("a")).to eq(1)
     end
   end
+
+  context 'support lazy entries' do
+    it 'by evaluating a bound proc' do
+      result = nil
+      context.override(:a => lambda {|| 'yay'}) do
+        result = context.lookup(:a)
+      end
+      expect(result).to eq('yay')
+    end
+
+    it 'by memoizing the bound value' do
+      result1 = nil
+      result2 = nil
+      original = 'yay'
+      context.override(:a => lambda {|| tmp = original; original = 'no'; tmp}) do
+        result1 = context.lookup(:a)
+        result2 = context.lookup(:a)
+      end
+      expect(result1).to eq('yay')
+      expect(original).to eq('no')
+      expect(result2).to eq('yay')
+    end
+  end
 end

data/spec/unit/environments_spec.rb

@@ -3,13 +3,17 @@ require 'puppet/environments'
 require 'puppet/file_system'
 require 'matchers/include'
 
+module PuppetEnvironments
 describe Puppet::Environments do
   include Matchers::Include
-  include PuppetSpec::Files
 
   FS = Puppet::FileSystem
 
   describe "directories loader" do
+    before(:each) do
+      Puppet.settings.initialize_global_settings
+    end
+
     it "lists environments" do
       global_path_1_location = File.expand_path("global_path_1")
       global_path_2_location = File.expand_path("global_path_2")
@@ -18,10 +22,13 @@ describe Puppet::Environments do
 
       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_directory("env2", [
+          FS::MemoryFile.a_missing_file("environment.conf"),
+        ]),
       ])
 
       loader_from(:filesystem => [envdir, global_path_1, global_path_2],
@@ -38,10 +45,14 @@ describe Puppet::Environments do
     end
 
     it "does not list files" do
-      envdir = FS::MemoryFile.a_directory("envdir", [
+      envdir = FS::MemoryFile.a_directory(File.expand_path("envdir"), [
         FS::MemoryFile.a_regular_file_containing("foo", ''),
-        FS::MemoryFile.a_directory("env1"),
-        FS::MemoryFile.a_directory("env2"),
+        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],
@@ -50,14 +61,18 @@ describe Puppet::Environments do
       end
     end
 
-    it "it ignores directories that are not valid env names (alphanumeric and _)" do
-      envdir = FS::MemoryFile.a_directory("envdir", [
+    it "ignores directories that are not valid env names (alphanumeric and _)" do
+      envdir = FS::MemoryFile.a_directory(File.expand_path("envdir"), [
         FS::MemoryFile.a_directory(".foo"),
         FS::MemoryFile.a_directory("bar-thing"),
         FS::MemoryFile.a_directory("with spaces"),
         FS::MemoryFile.a_directory("some.thing"),
-        FS::MemoryFile.a_directory("env1"),
-        FS::MemoryFile.a_directory("env2"),
+        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],
@@ -67,9 +82,13 @@ describe Puppet::Environments do
     end
 
     it "gets a particular environment" do
-      directory_tree = FS::MemoryFile.a_directory("envdir", [
-        FS::MemoryFile.a_directory("env1"),
-        FS::MemoryFile.a_directory("env2"),
+      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],
@@ -86,13 +105,243 @@ describe Puppet::Environments do
         expect(loader.get("env_not_in_this_list")).to be_nil
       end
     end
+
+    context "with an environment.conf" do
+      let(:envdir) do
+        FS::MemoryFile.a_directory(File.expand_path("envdir"), [
+          FS::MemoryFile.a_directory("env1", [
+            FS::MemoryFile.a_regular_file_containing("environment.conf", content),
+          ]),
+        ])
+      end
+      let(:manifestdir) { FS::MemoryFile.a_directory(File.expand_path("/some/manifest/path")) }
+      let(:modulepath) do
+        [
+          FS::MemoryFile.a_directory(File.expand_path("/some/module/path")),
+          FS::MemoryFile.a_directory(File.expand_path("/some/other/path")),
+        ]
+      end
+
+      let(:content) do
+        <<-EOF
+manifest=#{manifestdir}
+modulepath=#{modulepath.join(File::PATH_SEPARATOR)}
+config_version=/some/script
+        EOF
+      end
+
+      it "reads environment.conf settings" do
+        loader_from(:filesystem => [envdir, manifestdir, modulepath].flatten,
+                    :directory => envdir) do |loader|
+          expect(loader.get("env1")).to environment(:env1).
+            with_manifest(manifestdir.path).
+            with_modulepath(modulepath.map(&:path))
+        end
+      end
+
+      it "does not append global_module_path to environment.conf modulepath setting" do
+        global_path_location = File.expand_path("global_path")
+        global_path = FS::MemoryFile.a_directory(global_path_location)
+
+        loader_from(:filesystem => [envdir, manifestdir, modulepath, global_path].flatten,
+                    :directory => envdir,
+                    :modulepath => [global_path]) do |loader|
+          expect(loader.get("env1")).to environment(:env1).
+            with_manifest(manifestdir.path).
+            with_modulepath(modulepath.map(&:path))
+        end
+      end
+
+      it "reads config_version setting" do
+        loader_from(:filesystem => [envdir, manifestdir, modulepath].flatten,
+                    :directory => envdir) do |loader|
+          expect(loader.get("env1")).to environment(:env1).
+            with_manifest(manifestdir.path).
+            with_modulepath(modulepath.map(&:path)).
+            with_config_version(File.expand_path('/some/script'))
+        end
+      end
+
+      it "accepts an empty environment.conf without warning" do
+        content = nil
+
+        envdir = FS::MemoryFile.a_directory(File.expand_path("envdir"), [
+          FS::MemoryFile.a_directory("env1", [
+            FS::MemoryFile.a_regular_file_containing("environment.conf", content),
+          ]),
+        ])
+
+        manifestdir = FS::MemoryFile.a_directory(File.join(envdir, "env1", "manifests"))
+        modulesdir = FS::MemoryFile.a_directory(File.join(envdir, "env1", "modules"))
+        global_path_location = File.expand_path("global_path")
+        global_path = FS::MemoryFile.a_directory(global_path_location)
+
+        loader_from(:filesystem => [envdir, manifestdir, modulesdir, global_path].flatten,
+                    :directory => envdir,
+                    :modulepath => [global_path]) do |loader|
+          expect(loader.get("env1")).to environment(:env1).
+            with_manifest("#{FS.path_string(envdir)}/env1/manifests").
+            with_modulepath(["#{FS.path_string(envdir)}/env1/modules", global_path_location]).
+            with_config_version(nil)
+        end
+
+        expect(@logs).to be_empty
+      end
+
+      it "logs a warning, but processes the main settings if there are extraneous sections" do
+        content << "[foo]"
+        loader_from(:filesystem => [envdir, manifestdir, modulepath].flatten,
+                    :directory => envdir) do |loader|
+          expect(loader.get("env1")).to environment(:env1).
+            with_manifest(manifestdir.path).
+            with_modulepath(modulepath.map(&:path)).
+            with_config_version(File.expand_path('/some/script'))
+        end
+
+        expect(@logs.map(&:to_s).join).to match(/Invalid.*at.*#{envdir}\/env1.*may not have sections.*ignored: 'foo'/)
+      end
+
+      it "logs a warning, but processes the main settings if there are any extraneous settings" do
+        content << "dog=arf\n"
+        content << "cat=mew\n"
+        content << "[ignored]\n"
+        content << "cow=moo\n"
+        loader_from(:filesystem => [envdir, manifestdir, modulepath].flatten,
+                    :directory => envdir) do |loader|
+          expect(loader.get("env1")).to environment(:env1).
+            with_manifest(manifestdir.path).
+            with_modulepath(modulepath.map(&:path)).
+            with_config_version(File.expand_path('/some/script'))
+        end
+
+        expect(@logs.map(&:to_s).join).to match(/Invalid.*at.*#{envdir}\/env1.*unknown setting.*dog, cat/)
+      end
+
+      it "interpretes relative paths from the environment's directory" do
+        content = <<-EOF
+manifest=relative/manifest
+modulepath=relative/modules
+config_version=relative/script
+        EOF
+
+        envdir = FS::MemoryFile.a_directory(File.expand_path("envdir"), [
+          FS::MemoryFile.a_directory("env1", [
+            FS::MemoryFile.a_regular_file_containing("environment.conf", content),
+            FS::MemoryFile.a_missing_file("modules"),
+            FS::MemoryFile.a_directory('relative', [
+              FS::MemoryFile.a_directory('modules'),
+            ]),
+          ]),
+        ])
+
+        loader_from(:filesystem => [envdir],
+                    :directory => envdir) do |loader|
+          expect(loader.get("env1")).to environment(:env1).
+            with_manifest(File.join(envdir, 'env1', 'relative', 'manifest')).
+            with_modulepath([File.join(envdir, 'env1', 'relative', 'modules')]).
+            with_config_version(File.join(envdir, 'env1', 'relative', 'script'))
+        end
+      end
+
+      it "interpolates other setting values correctly" do
+        modulepath = [
+          File.expand_path('/some/absolute'),
+          '$basemodulepath',
+          'modules'
+        ].join(File::PATH_SEPARATOR)
+
+        content = <<-EOF
+manifest=$confdir/whackymanifests
+modulepath=#{modulepath}
+config_version=$vardir/random/scripts
+        EOF
+
+        some_absolute_dir = FS::MemoryFile.a_directory(File.expand_path('/some/absolute'))
+        base_module_dirs = Puppet[:basemodulepath].split(File::PATH_SEPARATOR).map do |path|
+          FS::MemoryFile.a_directory(path)
+        end
+        envdir = FS::MemoryFile.a_directory(File.expand_path("envdir"), [
+          FS::MemoryFile.a_directory("env1", [
+            FS::MemoryFile.a_regular_file_containing("environment.conf", content),
+            FS::MemoryFile.a_directory("modules"),
+          ]),
+        ])
+
+        loader_from(:filesystem => [envdir, some_absolute_dir, base_module_dirs].flatten,
+                    :directory => envdir) do |loader|
+          expect(loader.get("env1")).to environment(:env1).
+            with_manifest(File.join(Puppet[:confdir], 'whackymanifests')).
+            with_modulepath([some_absolute_dir.path,
+                            base_module_dirs.map { |d| d.path },
+                            File.join(envdir, 'env1', 'modules')].flatten).
+            with_config_version(File.join(Puppet[:vardir], 'random', 'scripts'))
+        end
+      end
+
+      it "uses environment.conf settings regardless of existence of modules and manifests subdirectories" do
+        envdir = FS::MemoryFile.a_directory(File.expand_path("envdir"), [
+          FS::MemoryFile.a_directory("env1", [
+            FS::MemoryFile.a_regular_file_containing("environment.conf", content),
+            FS::MemoryFile.a_directory("modules"),
+            FS::MemoryFile.a_directory("manifests"),
+          ]),
+        ])
+
+        loader_from(:filesystem => [envdir, manifestdir, modulepath].flatten,
+                    :directory => envdir) do |loader|
+          expect(loader.get("env1")).to environment(:env1).
+            with_manifest(manifestdir.path).
+            with_modulepath(modulepath.map(&:path)).
+            with_config_version(File.expand_path('/some/script'))
+        end
+      end
+    end
+  end
+
+  describe "static loaders" do
+    let(:static1) { Puppet::Node::Environment.create(:static1, []) }
+    let(:static2) { Puppet::Node::Environment.create(:static2, []) }
+    let(:loader) { Puppet::Environments::Static.new(static1, static2) }
+
+    it "lists environments" do
+      expect(loader.list).to eq([static1, static2])
+    end
+
+    it "gets an environment" do
+      expect(loader.get(:static2)).to eq(static2)
+    end
+
+    it "returns nil if env not found" do
+      expect(loader.get(:doesnotexist)).to be_nil
+    end
+
+    it "gets a basic conf" do
+      conf = loader.get_conf(:static1)
+      expect(conf.modulepath).to eq('')
+      expect(conf.manifest).to eq(:no_manifest)
+      expect(conf.config_version).to be_nil
+    end
+
+    it "returns nil if you request a configuration from an env that doesn't exist" do
+      expect(loader.get_conf(:doesnotexist)).to be_nil
+    end
+
+    context "that are private" do
+      let(:private_env) { Puppet::Node::Environment.create(:private, []) }
+      let(:loader) { Puppet::Environments::StaticPrivate.new(private_env) }
+
+      it "lists nothing" do
+        expect(loader.list).to eq([])
+      end
+    end
   end
 
   RSpec::Matchers.define :environment do |name|
     match do |env|
       env.name == name &&
         (!@manifest || @manifest == env.manifest) &&
-        (!@modulepath || @modulepath == env.modulepath)
+        (!@modulepath || @modulepath == env.modulepath) &&
+        (!@config_version || @config_version == env.config_version)
     end
 
     chain :with_manifest do |manifest|
@@ -103,23 +352,32 @@ describe Puppet::Environments do
       @modulepath = modulepath
     end
 
+    chain :with_config_version do |config_version|
+      @config_version = config_version
+    end
+
     description do
       "environment #{expected}" +
         (@manifest ? " with manifest #{@manifest}" : "") +
-        (@modulepath ? " with modulepath [#{@modulepath.join(', ')}]" : "")
+        (@modulepath ? " with modulepath [#{@modulepath.join(', ')}]" : "") +
+        (@config_version ? " with config_version #{@config_version}" : "")
     end
 
     failure_message_for_should do |env|
-      "expected <#{env.name}: modulepath = [#{env.modulepath.join(', ')}], manifest = #{env.manifest}> to be #{description}"
+      "expected <#{env.name}: modulepath = [#{env.modulepath.join(', ')}], manifest = #{env.manifest}, config_version = #{env.config_version}> to be #{description}"
     end
   end
 
   def loader_from(options, &block)
     FS.overlay(*options[:filesystem]) do
-      yield Puppet::Environments::Directories.new(
+      environments = Puppet::Environments::Directories.new(
         options[:directory],
         options[:modulepath] || []
       )
+      Puppet.override(:environments => environments) do
+        yield environments
+      end
     end
   end
 end
+end