puppet 3.4.3 → 3.5.0.rc1

data/spec/unit/environments_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+require 'puppet/environments'
+require 'puppet/file_system'
+require 'matchers/include'
+
+describe Puppet::Environments do
+  include Matchers::Include
+  include PuppetSpec::Files
+
+  FS = Puppet::FileSystem
+
+  describe "directories loader" do
+
+    RSpec::Matchers.define :environment do |name|
+      match do |env|
+        env.name == name &&
+          (!@manifest || @manifest == env.manifest) &&
+          (!@modulepath || @modulepath == env.modulepath)
+      end
+
+      chain :with_manifest do |manifest|
+        @manifest = manifest
+      end
+
+      chain :with_modulepath do |modulepath|
+        @modulepath = modulepath
+      end
+
+      description do
+        "environment #{expected}" +
+          (@manifest ? " with manifest #{@manifest}" : "") +
+          (@modulepath ? " with modulepath [#{@modulepath.join(', ')}]" : "")
+      end
+
+      failure_message_for_should do |env|
+        "expected <#{env.name}: modulepath = [#{env.modulepath.join(', ')}], manifest = #{env.manifest}> to be #{description}"
+      end
+    end
+
+    def loader_from(options, &block)
+      FS.overlay(*options[:filesystem]) do
+        yield Puppet::Environments::Directories.new(
+          options[:directory],
+          options[:modulepath] || []
+        )
+      end
+    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")
+      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_directory("modules"),
+          FS::MemoryFile.a_directory("manifests"),
+        ]),
+        FS::MemoryFile.a_directory("env2")
+      ])
+
+      loader_from(:filesystem => [envdir, global_path_1, global_path_2],
+                  :directory => envdir,
+                  :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",
+                             global_path_1_location,
+                             global_path_2_location]),
+          environment(:env2))
+      end
+    end
+
+    it "does not list files" do
+      envdir = FS::MemoryFile.a_directory("envdir", [
+        FS::MemoryFile.a_regular_file_containing("foo", ''),
+        FS::MemoryFile.a_directory("env1"),
+        FS::MemoryFile.a_directory("env2"),
+      ])
+
+      loader_from(:filesystem => [envdir],
+                  :directory => envdir) do |loader|
+        expect(loader.list).to include_in_any_order(environment(:env1), environment(:env2))
+      end
+    end
+
+    it "it ignores directories that are not valid env names (alphanumeric and _)" do
+      envdir = FS::MemoryFile.a_directory("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"),
+      ])
+
+      loader_from(:filesystem => [envdir],
+                  :directory => envdir) do |loader|
+        expect(loader.list).to include_in_any_order(environment(:env1), environment(:env2))
+      end
+    end
+
+    it "gets a particular environment" do
+      directory_tree = FS::MemoryFile.a_directory("envdir", [
+        FS::MemoryFile.a_directory("env1"),
+        FS::MemoryFile.a_directory("env2"),
+      ])
+
+      loader_from(:filesystem => [directory_tree],
+                  :directory => directory_tree) do |loader|
+        expect(loader.get("env1")).to environment(:env1)
+      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
+  end
+end

data/spec/unit/face/config_spec.rb

@@ -3,29 +3,44 @@ require 'spec_helper'
 require 'puppet/face'
 
 describe Puppet::Face[:config, '0.0.1'] do
-  it "should use Settings#print_config_options when asked to print" do
-    Puppet.settings.stubs(:puts)
-    Puppet.settings.expects(:print_config_options)
-    subject.print
+  it "prints a single setting without the name" do
+    Puppet[:trace] = true
+
+    subject.expects(:puts).with(true)
+
+    subject.print("trace").should be_nil
   end
 
-  it "should set 'configprint' to all desired values and call print_config_options when a specific value is provided" do
-    Puppet.settings.stubs(:puts)
-    Puppet.settings.expects(:print_config_options)
-    subject.print("libdir", "ssldir")
-    Puppet.settings[:configprint].should == "libdir,ssldir"
+  it "prints multiple settings with the names" do
+    Puppet[:trace] = true
+    Puppet[:syslogfacility] = "file"
+
+    subject.expects(:puts).with("trace = true")
+    subject.expects(:puts).with("syslogfacility = file")
+
+    subject.print("trace", "syslogfacility")
   end
 
-  it "should always return nil" do
-    Puppet.settings.stubs(:puts)
-    Puppet.settings.expects(:print_config_options)
-    subject.print("libdir").should be_nil
+  it "prints the setting from the selected section" do
+    Puppet.settings.parse_config(<<-CONF)
+    [other]
+    syslogfacility = file
+    CONF
+
+    subject.expects(:puts).with("file")
+
+    subject.print("syslogfacility", :section => "other")
   end
 
   it "should default to all when no arguments are given" do
-    Puppet.settings.stubs(:puts)
-    Puppet.settings.expects(:print_config_options)
+    subject.expects(:puts).times(Puppet.settings.to_a.length)
+
     subject.print
-    Puppet.settings[:configprint].should == "all"
+  end
+
+  it "prints out all of the settings when asked for 'all'" do
+    subject.expects(:puts).times(Puppet.settings.to_a.length)
+
+    subject.print('all')
   end
 end

data/spec/unit/face/module/build_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'puppet/face'
+require 'puppet/module_tool'
 
 describe "puppet module build" do
   subject { Puppet::Face[:module, :current] }

data/spec/unit/face/module/install_spec.rb

@@ -7,43 +7,43 @@ describe "puppet module install" do
 
   subject { Puppet::Face[:module, :current] }
 
-  let(:options) do
-    {}
-  end
-
   describe "option validation" do
-    before do
-      Puppet.settings[:modulepath] = fakemodpath
+    let(:sep) { File::PATH_SEPARATOR }
+    let(:fakefirstpath)  { make_absolute("/my/fake/modpath") }
+    let(:fakesecondpath) { make_absolute("/other/fake/path") }
+    let(:fakemodpath)    { "#{fakefirstpath}#{sep}#{fakesecondpath}" }
+    let(:fakedirpath)    { make_absolute("/my/fake/path") }
+    let(:options) { {} }
+    let(:environment) do
+      Puppet::Node::Environment.create(:env, [fakefirstpath, fakesecondpath], '')
     end
-
     let(:expected_options) do
       {
         :target_dir  => fakefirstpath,
-        :modulepath  => fakemodpath,
-        :environment => 'production'
+        :environment_instance => environment,
       }
     end
 
-    let(:sep) { File::PATH_SEPARATOR }
-    let(:fakefirstpath)  { make_absolute("/my/fake/modpath") }
-    let(:fakesecondpath) { make_absolute("/other/fake/path") }
-    let(:fakemodpath)    { "#{fakefirstpath}#{sep}#{fakesecondpath}" }
-    let(:fakedirpath)    { make_absolute("/my/fake/path") }
+    around(:each) do |example|
+      Puppet.override(:current_environment => environment) do
+        example.run
+      end
+    end
 
     context "without any options" do
-      it "should require a name" do
+      it "requires a name" do
         pattern = /wrong number of arguments/
         expect { subject.install }.to raise_error ArgumentError, pattern
       end
 
-      it "should not require any options" do
+      it "does not require any options" do
         expects_installer_run_with("puppetlabs-apache", expected_options)
 
         subject.install("puppetlabs-apache")
       end
     end
 
-    it "should accept the --force option" do
+    it "accepts the --force option" do
       options[:force] = true
       expected_options.merge!(options)
 
@@ -52,17 +52,17 @@ describe "puppet module install" do
       subject.install("puppetlabs-apache", options)
     end
 
-    it "should accept the --target-dir option" do
+    it "accepts the --target-dir option" do
       options[:target_dir] = make_absolute("/foo/puppet/modules")
       expected_options.merge!(options)
-      expected_options[:modulepath] = "#{options[:target_dir]}#{sep}#{fakemodpath}"
+      expected_options[:environment_instance] = environment.override_with(:modulepath => [options[:target_dir], fakefirstpath, fakesecondpath])
 
       expects_installer_run_with("puppetlabs-apache", expected_options)
 
       subject.install("puppetlabs-apache", options)
     end
 
-    it "should accept the --version option" do
+    it "accepts the --version option" do
       options[:version] = "0.0.1"
       expected_options.merge!(options)
 
@@ -71,7 +71,7 @@ describe "puppet module install" do
       subject.install("puppetlabs-apache", options)
     end
 
-    it "should accept the --ignore-dependencies option" do
+    it "accepts the --ignore-dependencies option" do
       options[:ignore_dependencies] = true
       expected_options.merge!(options)
 
@@ -79,89 +79,6 @@ describe "puppet module install" do
 
       subject.install("puppetlabs-apache", options)
     end
-
-    describe "when modulepath option is passed" do
-      let(:expected_options) { { :modulepath => fakemodpath, :environment => Puppet[:environment] } }
-      let(:options)          { { :modulepath => fakemodpath } }
-
-      describe "when target-dir option is not passed" do
-        it "should set target-dir to be first path from modulepath" do
-          expected_options[:target_dir] = fakefirstpath
-
-          expects_installer_run_with("puppetlabs-apache", expected_options)
-
-          Puppet::Face[:module, :current].install("puppetlabs-apache", options)
-
-          Puppet.settings[:modulepath].should == fakemodpath
-        end
-
-        it "should expand the target directory derived from the modulepath" do
-          options[:modulepath] = "modules"
-          expanded_path = File.expand_path("modules")
-          expected_options.merge!(options)
-          expected_options[:target_dir] = expanded_path
-          expected_options[:modulepath] = "modules"
-
-          expects_installer_run_with("puppetlabs-apache", expected_options)
-          Puppet::Face[:module, :current].install("puppetlabs-apache", options)
-        end
-      end
-
-      describe "when target-dir option is passed" do
-        it "should set target-dir to be first path of modulepath" do
-          options[:target_dir] = fakedirpath
-          expected_options[:target_dir] = fakedirpath
-          expected_options[:modulepath] = "#{fakedirpath}#{sep}#{fakemodpath}"
-
-          expects_installer_run_with("puppetlabs-apache", expected_options)
-
-          Puppet::Face[:module, :current].install("puppetlabs-apache", options)
-
-          Puppet.settings[:modulepath].should == "#{fakedirpath}#{sep}#{fakemodpath}"
-        end
-      end
-    end
-
-    describe "when modulepath option is not passed" do
-      before do
-        Puppet.settings[:modulepath] = fakemodpath
-      end
-
-      describe "when target-dir option is not passed" do
-        it "should set target-dir to be first path of default mod path" do
-          expected_options[:target_dir] = fakefirstpath
-          expected_options[:modulepath] = fakemodpath
-
-          expects_installer_run_with("puppetlabs-apache", expected_options)
-
-          Puppet::Face[:module, :current].install("puppetlabs-apache", options)
-        end
-      end
-
-      describe "when target-dir option is passed" do
-        it "should prepend target-dir to modulepath" do
-          options[:target_dir] = fakedirpath
-          expected_options[:target_dir] = fakedirpath
-          expected_options[:modulepath] = "#{options[:target_dir]}#{sep}#{fakemodpath}"
-
-          expects_installer_run_with("puppetlabs-apache", expected_options)
-
-          Puppet::Face[:module, :current].install("puppetlabs-apache", options)
-          Puppet.settings[:modulepath].should == expected_options[:modulepath]
-        end
-
-        it "should expand the target directory when target_dir is set" do
-          options[:target_dir] = "modules"
-          expanded_path = File.expand_path("modules")
-          expected_options.merge!(options)
-          expected_options[:target_dir] = expanded_path
-          expected_options[:modulepath] = "#{expanded_path}#{sep}#{fakemodpath}"
-
-          expects_installer_run_with("puppetlabs-apache", expected_options)
-          Puppet::Face[:module, :current].install("puppetlabs-apache", options)
-        end
-      end
-    end
   end
 
   describe "inline documentation" do

data/spec/unit/face/module/list_spec.rb

@@ -20,6 +20,12 @@ describe "puppet module list" do
     FileUtils.mkdir_p(@modpath2)
   end
 
+  around do |example|
+    Puppet.override(:environments => Puppet::Environments::Legacy.new()) do
+      example.run
+    end
+  end
+
   it "should return an empty list per dir in path if there are no modules" do
     Puppet.settings[:modulepath] = @modulepath
     Puppet::Face[:module, :current].list.should == {
@@ -33,58 +39,68 @@ describe "puppet module list" do
     barmod1 = PuppetSpec::Modules.create('bar', @modpath1)
     foomod2 = PuppetSpec::Modules.create('foo', @modpath2)
 
-    env = Puppet::Node::Environment.new
+    usedenv = Puppet::Node::Environment.create(:useme, [@modpath1, @modpath2], '')
 
-    Puppet::Face[:module, :current].list.should == {
-      @modpath1 => [
-        Puppet::Module.new('bar', barmod1.path, env),
-        Puppet::Module.new('foo', foomod1.path, env)
-      ],
-      @modpath2 => [Puppet::Module.new('foo', foomod2.path, env)]
-    }
+    Puppet.override(:environments => Puppet::Environments::Static.new(usedenv)) do
+      Puppet::Face[:module, :current].list(:environment => 'useme').should == {
+        @modpath1 => [
+          Puppet::Module.new('bar', barmod1.path, usedenv),
+          Puppet::Module.new('foo', foomod1.path, usedenv)
+        ],
+        @modpath2 => [Puppet::Module.new('foo', foomod2.path, usedenv)]
+      }
+    end
   end
 
   it "should use the specified environment" do
     foomod = PuppetSpec::Modules.create('foo', @modpath1)
     barmod = PuppetSpec::Modules.create('bar', @modpath1)
 
-    usedenv = Puppet::Node::Environment.new('useme')
-    usedenv.modulepath = [@modpath1, @modpath2]
+    usedenv = Puppet::Node::Environment.create(:useme, [@modpath1, @modpath2], '')
 
-    Puppet::Face[:module, :current].list(:environment => 'useme').should == {
-      @modpath1 => [
-        Puppet::Module.new('bar', barmod.path, usedenv),
-        Puppet::Module.new('foo', foomod.path, usedenv)
-      ],
-      @modpath2 => []
-    }
+    Puppet.override(:environments => Puppet::Environments::Static.new(usedenv)) do
+      Puppet::Face[:module, :current].list(:environment => 'useme').should == {
+        @modpath1 => [
+          Puppet::Module.new('bar', barmod.path, usedenv),
+          Puppet::Module.new('foo', foomod.path, usedenv)
+        ],
+        @modpath2 => []
+      }
+    end
   end
 
   it "should use the specified modulepath" do
     foomod = PuppetSpec::Modules.create('foo', @modpath1)
     barmod = PuppetSpec::Modules.create('bar', @modpath2)
 
-    Puppet::Face[:module, :current].list(:modulepath => "#{@modpath1}#{File::PATH_SEPARATOR}#{@modpath2}").should == {
-      @modpath1 => [ Puppet::Module.new('foo', foomod.path, Puppet::Node::Environment.new) ],
-      @modpath2 => [ Puppet::Module.new('bar', barmod.path, Puppet::Node::Environment.new) ]
-    }
+    modules = Puppet::Face[:module, :current].list(:modulepath => "#{@modpath1}#{File::PATH_SEPARATOR}#{@modpath2}")
+
+    expect(modules[@modpath1].first.name).to eq('foo')
+    expect(modules[@modpath1].first.path).to eq(foomod.path)
+    expect(modules[@modpath1].first.environment.modulepath).to eq([@modpath1, @modpath2])
+
+    expect(modules[@modpath2].first.name).to eq('bar')
+    expect(modules[@modpath2].first.path).to eq(barmod.path)
+    expect(modules[@modpath2].first.environment.modulepath).to eq([@modpath1, @modpath2])
   end
 
-  it "should use the specified modulepath over the specified environment in place of the environment's default path" do
-    foomod1 = PuppetSpec::Modules.create('foo', @modpath1)
-    barmod2 = PuppetSpec::Modules.create('bar', @modpath2)
-    env = Puppet::Node::Environment.new('myenv')
-    env.modulepath = ['/tmp/notused']
-
-    list = Puppet::Face[:module, :current].list(:environment => 'myenv', :modulepath => "#{@modpath1}#{File::PATH_SEPARATOR}#{@modpath2}")
-
-    # Changing Puppet[:modulepath] causes Puppet::Node::Environment.new('myenv')
-    # to have a different object_id than the env above
-    env = Puppet::Node::Environment.new('myenv')
-    list.should == {
-      @modpath1 => [ Puppet::Module.new('foo', foomod1.path, env) ],
-      @modpath2 => [ Puppet::Module.new('bar', barmod2.path, env) ]
-    }
+  it "prefers a given modulepath over the modulepath from the given environment" do
+    foomod = PuppetSpec::Modules.create('foo', @modpath1)
+    barmod = PuppetSpec::Modules.create('bar', @modpath2)
+    env = Puppet::Node::Environment.create(:myenv, ['/tmp/notused'], '')
+    Puppet[:modulepath] = ""
+
+    modules = Puppet::Face[:module, :current].list(:environment => 'myenv', :modulepath => "#{@modpath1}#{File::PATH_SEPARATOR}#{@modpath2}")
+
+    expect(modules[@modpath1].first.name).to eq('foo')
+    expect(modules[@modpath1].first.path).to eq(foomod.path)
+    expect(modules[@modpath1].first.environment.modulepath).to eq([@modpath1, @modpath2])
+    expect(modules[@modpath1].first.environment.name).to_not eq(:myenv)
+
+    expect(modules[@modpath2].first.name).to eq('bar')
+    expect(modules[@modpath2].first.path).to eq(barmod.path)
+    expect(modules[@modpath2].first.environment.modulepath).to eq([@modpath1, @modpath2])
+    expect(modules[@modpath2].first.environment.name).to_not eq(:myenv)
   end
 
   describe "inline documentation" do