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

data/spec/unit/face/config_spec.rb

@@ -2,23 +2,25 @@
 require 'spec_helper'
 require 'puppet/face'
 
+module PuppetFaceSpecs 
 describe Puppet::Face[:config, '0.0.1'] do
+
+  FS = Puppet::FileSystem
+
   it "prints a single setting without the name" do
     Puppet[:trace] = true
 
-    subject.expects(:puts).with(true)
-
-    subject.print("trace").should be_nil
+    expect { subject.print("trace") }.to have_printed('true')
   end
 
   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")
+    expect { subject.print("trace", "syslogfacility") }.to have_printed(<<-OUTPUT)
+trace = true
+syslogfacility = file
+    OUTPUT
   end
 
   it "prints the setting from the selected section" do
@@ -27,12 +29,10 @@ describe Puppet::Face[:config, '0.0.1'] do
     syslogfacility = file
     CONF
 
-    subject.expects(:puts).with("file")
-
-    subject.print("syslogfacility", :section => "other")
+    expect { subject.print("syslogfacility", :section => "other") }.to have_printed('file')
   end
 
-  it "should default to all when no arguments are given" do
+  it "defaults to all when no arguments are given" do
     subject.expects(:puts).times(Puppet.settings.to_a.length)
 
     subject.print
@@ -43,4 +43,104 @@ describe Puppet::Face[:config, '0.0.1'] do
 
     subject.print('all')
   end
+
+  shared_examples_for :config_printing_a_section do |section|
+
+    def add_section_option(args, section)
+      args << { :section => section } if section
+      args
+    end
+
+    it "prints directory env settings for an env that exists" do
+      FS.overlay(
+        FS::MemoryFile.a_directory(File.expand_path("/dev/null/environments"), [
+          FS::MemoryFile.a_directory("production", [
+            FS::MemoryFile.a_missing_file("environment.conf"),
+          ]),
+        ])
+      ) do
+        args = "environmentpath","manifest","modulepath","environment","basemodulepath"
+        expect { subject.print(*add_section_option(args, section)) }.to have_printed(<<-OUTPUT)
+environmentpath = #{File.expand_path("/dev/null/environments")}
+manifest = #{File.expand_path("/dev/null/environments/production/manifests")}
+modulepath = #{File.expand_path("/dev/null/environments/production/modules")}#{File::PATH_SEPARATOR}#{File.expand_path("/some/base")}
+environment = production
+basemodulepath = #{File.expand_path("/some/base")}
+        OUTPUT
+      end
+    end
+
+    it "interpolates settings in environment.conf" do
+      FS.overlay(
+        FS::MemoryFile.a_directory(File.expand_path("/dev/null/environments"), [
+          FS::MemoryFile.a_directory("production", [
+            FS::MemoryFile.a_regular_file_containing("environment.conf", <<-CONTENT),
+            modulepath=/custom/modules#{File::PATH_SEPARATOR}$basemodulepath
+            CONTENT
+          ]),
+        ])
+      ) do
+        args = "environmentpath","manifest","modulepath","environment","basemodulepath"
+        expect { subject.print(*add_section_option(args, section)) }.to have_printed(<<-OUTPUT)
+environmentpath = #{File.expand_path("/dev/null/environments")}
+manifest = #{File.expand_path("/dev/null/environments/production/manifests")}
+modulepath = #{File.expand_path("/custom/modules")}#{File::PATH_SEPARATOR}#{File.expand_path("/some/base")}
+environment = production
+basemodulepath = #{File.expand_path("/some/base")}
+        OUTPUT
+      end
+    end
+
+    it "prints the default configured env settings for an env that does not exist" do
+      Puppet[:environment] = 'doesnotexist'
+
+      FS.overlay(
+        FS::MemoryFile.a_directory(File.expand_path("/dev/null/environments"), [
+          FS::MemoryFile.a_missing_file("doesnotexist")
+        ])
+      ) do
+        args = "environmentpath","manifest","modulepath","environment","basemodulepath"
+        expect { subject.print(*add_section_option(args, section)) }.to have_printed(<<-OUTPUT)
+environmentpath = #{File.expand_path("/dev/null/environments")}
+manifest = no_manifest
+modulepath = 
+environment = doesnotexist
+basemodulepath = #{File.expand_path("/some/base")}
+        OUTPUT
+      end
+    end
+  end
+
+  context "when printing environment settings" do
+    before(:each) do
+      Puppet.settings.stubs(:global_defaults_initialized?).returns(:true)
+    end
+
+    context "from main section" do
+      before(:each) do
+        Puppet.settings.parse_config(<<-CONF)
+        [main]
+        environmentpath=$confdir/environments
+        basemodulepath=/some/base
+        CONF
+      end
+
+      it_behaves_like :config_printing_a_section
+    end
+
+    context "from master section" do
+
+      before(:each) do
+        Puppet.settings.parse_config(<<-CONF)
+        [master]
+        environmentpath=$confdir/environments
+        basemodulepath=/some/base
+        CONF
+        Puppet.settings.stubs(:global_defaults_initialized?).returns(:true)
+      end
+
+      it_behaves_like :config_printing_a_section, :master
+    end
+  end
+end
 end

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

@@ -5,84 +5,28 @@ require 'puppet/module_tool'
 describe "puppet module install" do
   include PuppetSpec::Files
 
-  subject { Puppet::Face[:module, :current] }
+  describe "action" do
+    let(:name)        { stub(:name) }
+    let(:target_dir)  { stub(:target_dir) }
+    let(:target_path) { stub(:target_path) }
+    let(:install_dir) { stub(:install_dir) }
+    let(:options)     { { :target_dir => target_dir } }
 
-  describe "option validation" do
-    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,
-        :environment_instance => environment,
-      }
-    end
-
-    around(:each) do |example|
-      Puppet.override(:current_environment => environment) do
-        example.run
-      end
-    end
-
-    context "without any options" do
-      it "requires a name" do
-        pattern = /wrong number of arguments/
-        expect { subject.install }.to raise_error ArgumentError, pattern
-      end
-
-      it "does not require any options" do
-        expects_installer_run_with("puppetlabs-apache", expected_options)
-
-        subject.install("puppetlabs-apache")
-      end
-    end
-
-    it "accepts the --force option" do
-      options[:force] = true
-      expected_options.merge!(options)
-
-      expects_installer_run_with("puppetlabs-apache", expected_options)
+    it 'should invoke the Installer app' do
+      args = [ name, install_dir, options ]
 
-      subject.install("puppetlabs-apache", options)
-    end
-
-    it "accepts the --target-dir option" do
-      options[:target_dir] = make_absolute("/foo/puppet/modules")
-      expected_options.merge!(options)
-      expected_options[:environment_instance] = environment.override_with(:modulepath => [options[:target_dir], fakefirstpath, fakesecondpath])
+      Puppet::ModuleTool.expects(:set_option_defaults).with(options)
 
-      expects_installer_run_with("puppetlabs-apache", expected_options)
+      Pathname.expects(:new).with(target_dir).returns(target_path)
+      Puppet::ModuleTool::InstallDirectory.expects(:new).with(target_path).returns(install_dir)
+      Puppet::ModuleTool::Applications::Installer.expects(:run).with(*args)
 
-      subject.install("puppetlabs-apache", options)
-    end
-
-    it "accepts the --version option" do
-      options[:version] = "0.0.1"
-      expected_options.merge!(options)
-
-      expects_installer_run_with("puppetlabs-apache", expected_options)
-
-      subject.install("puppetlabs-apache", options)
-    end
-
-    it "accepts the --ignore-dependencies option" do
-      options[:ignore_dependencies] = true
-      expected_options.merge!(options)
-
-      expects_installer_run_with("puppetlabs-apache", expected_options)
-
-      subject.install("puppetlabs-apache", options)
+      Puppet::Face[:module, :current].install(name, options)
     end
   end
 
   describe "inline documentation" do
-    subject { Puppet::Face[:module, :current].get_action :install }
+    subject { Puppet::Face.find_action(:module, :install) }
 
     its(:summary)     { should =~ /install.*module/im }
     its(:description) { should =~ /install.*module/im }
@@ -95,19 +39,4 @@ describe "puppet module install" do
       end
     end
   end
-
-  def expects_installer_run_with(name, options)
-    installer = mock("Installer")
-    install_dir = mock("InstallDir")
-    forge = mock("Forge")
-
-    Puppet::Forge.expects(:new).with("PMT", subject.version).returns(forge)
-    Puppet::ModuleTool::InstallDirectory.expects(:new).
-      with(Pathname.new(expected_options[:target_dir])).
-      returns(install_dir)
-    Puppet::ModuleTool::Applications::Installer.expects(:new).
-      with("puppetlabs-apache", forge, install_dir, expected_options).
-      returns(installer)
-    installer.expects(:run)
-  end
 end

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

@@ -8,27 +8,21 @@ require 'puppet_spec/modules'
 describe "puppet module list" do
   include PuppetSpec::Files
 
-  before do
+  around do |example|
     dir = tmpdir("deep_path")
 
-    @modpath1 = File.join(dir, "modpath1")
-    @modpath2 = File.join(dir, "modpath2")
-    @modulepath = "#{@modpath1}#{File::PATH_SEPARATOR}#{@modpath2}"
-    Puppet.settings[:modulepath] = @modulepath
-
-    FileUtils.mkdir_p(@modpath1)
-    FileUtils.mkdir_p(@modpath2)
-  end
+    FileUtils.mkdir_p(@modpath1 = File.join(dir, "modpath1"))
+    FileUtils.mkdir_p(@modpath2 = File.join(dir, "modpath2"))
+    FileUtils.mkdir_p(@modpath3 = File.join(dir, "modpath3"))
 
-  around do |example|
-    Puppet.override(:environments => Puppet::Environments::Legacy.new()) do
+    env = Puppet::Node::Environment.create(:env, [@modpath1, @modpath2])
+    Puppet.override(:current_environment => env) 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 == {
+    Puppet::Face[:module, :current].list[:modules_by_path].should == {
       @modpath1 => [],
       @modpath2 => []
     }
@@ -39,15 +33,16 @@ describe "puppet module list" do
     barmod1 = PuppetSpec::Modules.create('bar', @modpath1)
     foomod2 = PuppetSpec::Modules.create('foo', @modpath2)
 
-    usedenv = Puppet::Node::Environment.create(:useme, [@modpath1, @modpath2])
+    usedenv = Puppet::Node::Environment.create(:useme, [@modpath1, @modpath2, @modpath3])
 
     Puppet.override(:environments => Puppet::Environments::Static.new(usedenv)) do
-      Puppet::Face[:module, :current].list(:environment => 'useme').should == {
+      Puppet::Face[:module, :current].list(:environment => 'useme')[:modules_by_path].should == {
         @modpath1 => [
           Puppet::Module.new('bar', barmod1.path, usedenv),
           Puppet::Module.new('foo', foomod1.path, usedenv)
         ],
-        @modpath2 => [Puppet::Module.new('foo', foomod2.path, usedenv)]
+        @modpath2 => [Puppet::Module.new('foo', foomod2.path, usedenv)],
+        @modpath3 => [],
       }
     end
   end
@@ -56,15 +51,16 @@ describe "puppet module list" do
     foomod = PuppetSpec::Modules.create('foo', @modpath1)
     barmod = PuppetSpec::Modules.create('bar', @modpath1)
 
-    usedenv = Puppet::Node::Environment.create(:useme, [@modpath1, @modpath2])
+    usedenv = Puppet::Node::Environment.create(:useme, [@modpath1, @modpath2, @modpath3])
 
     Puppet.override(:environments => Puppet::Environments::Static.new(usedenv)) do
-      Puppet::Face[:module, :current].list(:environment => 'useme').should == {
+      Puppet::Face[:module, :current].list(:environment => 'useme')[:modules_by_path].should == {
         @modpath1 => [
           Puppet::Module.new('bar', barmod.path, usedenv),
           Puppet::Module.new('foo', foomod.path, usedenv)
         ],
-        @modpath2 => []
+        @modpath2 => [],
+        @modpath3 => [],
       }
     end
   end
@@ -73,7 +69,7 @@ describe "puppet module list" do
     foomod = PuppetSpec::Modules.create('foo', @modpath1)
     barmod = PuppetSpec::Modules.create('bar', @modpath2)
 
-    modules = Puppet::Face[:module, :current].list(:modulepath => "#{@modpath1}#{File::PATH_SEPARATOR}#{@modpath2}")
+    modules = Puppet::Face[:module, :current].list(:modulepath => "#{@modpath1}#{File::PATH_SEPARATOR}#{@modpath2}")[:modules_by_path]
 
     expect(modules[@modpath1].first.name).to eq('foo')
     expect(modules[@modpath1].first.path).to eq(foomod.path)
@@ -88,9 +84,8 @@ describe "puppet module list" 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}")
+    modules = Puppet::Face[:module, :current].list(:environment => 'myenv', :modulepath => "#{@modpath1}#{File::PATH_SEPARATOR}#{@modpath2}")[:modules_by_path]
 
     expect(modules[@modpath1].first.name).to eq('foo')
     expect(modules[@modpath1].first.path).to eq(foomod.path)
@@ -104,7 +99,7 @@ describe "puppet module list" do
   end
 
   describe "inline documentation" do
-    subject { Puppet::Face[:module, :current].get_action :list }
+    subject { Puppet::Face[:module, :current].get_action(:list) }
 
     its(:summary)     { should =~ /list.*module/im }
     its(:description) { should =~ /list.*module/im }
@@ -112,33 +107,41 @@ describe "puppet module list" do
     its(:examples)    { should_not be_empty }
   end
 
-  describe "when rendering" do
+  describe "when rendering to console" do
+    let(:face) { Puppet::Face[:module, :current] }
+    let(:action) { face.get_action(:list) }
+
+    def console_output(options={})
+      result = face.list(options)
+      action.when_rendering(:console).call(result, options)
+    end
+
     it "should explicitly state when a modulepath is empty" do
       empty_modpath = tmpdir('empty')
-      Puppet::Face[:module, :current].list_when_rendering_console(
-        { empty_modpath => [] },
-        {:modulepath => empty_modpath}
-      ).should == <<-HEREDOC.gsub('        ', '')
+
+      expected = <<-HEREDOC.gsub('        ', '')
         #{empty_modpath} (no modules installed)
       HEREDOC
+
+      console_output(:modulepath => empty_modpath).should == expected
     end
 
     it "should print both modules with and without metadata" do
       modpath = tmpdir('modpath')
-      Puppet.settings[:modulepath] = modpath
+
       PuppetSpec::Modules.create('nometadata', modpath)
       PuppetSpec::Modules.create('metadata', modpath, :metadata => {:author => 'metaman'})
 
-      dependency_tree = Puppet::Face[:module, :current].list
-
-      output = Puppet::Face[:module, :current].
-        list_when_rendering_console(dependency_tree, {})
-
-      output.should == <<-HEREDOC.gsub('        ', '')
-        #{modpath}
-        ├── metaman-metadata (\e[0;36mv9.9.9\e[0m)
-        └── nometadata (\e[0;36m???\e[0m)
+      env = Puppet::Node::Environment.create(:environ, [modpath])
+      Puppet.override(:current_environment => env) do
+        expected = <<-HEREDOC.gsub('          ', '')
+          #{modpath}
+          ├── metaman-metadata (\e[0;36mv9.9.9\e[0m)
+          └── nometadata (\e[0;36m???\e[0m)
         HEREDOC
+
+        console_output.should == expected
+      end
     end
 
     it "should print the modulepaths in the order they are in the modulepath setting" do
@@ -146,21 +149,16 @@ describe "puppet module list" do
       path2 = tmpdir('c')
       path3 = tmpdir('a')
 
-      sep = File::PATH_SEPARATOR
-      Puppet.settings[:modulepath] = "#{path1}#{sep}#{path2}#{sep}#{path3}"
-
-      Puppet::Face[:module, :current].list_when_rendering_console(
-        {
-          path2 => [],
-          path3 => [],
-          path1 => [],
-        },
-        {}
-      ).should == <<-HEREDOC.gsub('        ', '')
-        #{path1} (no modules installed)
-        #{path2} (no modules installed)
-        #{path3} (no modules installed)
-      HEREDOC
+      env = Puppet::Node::Environment.create(:environ, [path1, path2, path3])
+      Puppet.override(:current_environment => env) do
+        expected = <<-HEREDOC.gsub('          ', '')
+          #{path1} (no modules installed)
+          #{path2} (no modules installed)
+          #{path3} (no modules installed)
+        HEREDOC
+
+        console_output.should == expected
+      end
     end
 
     it "should print dependencies as a tree" do
@@ -177,19 +175,67 @@ describe "puppet module list" do
         }
       )
 
-      dependency_tree = Puppet::Face[:module, :current].list
-
-      output = Puppet::Face[:module, :current].list_when_rendering_console(
-        dependency_tree,
-        {:tree => true}
-      )
-
-      output.should == <<-HEREDOC.gsub('        ', '')
+      expected = <<-HEREDOC.gsub('        ', '')
         #{@modpath1}
         └─┬ puppetlabs-other_mod (\e[0;36mv1.0.0\e[0m)
           └── puppetlabs-dependable (\e[0;36mv0.0.5\e[0m)
         #{@modpath2} (no modules installed)
-        HEREDOC
+      HEREDOC
+
+      console_output(:tree => true).should == expected
+    end
+
+    it "should print both modules with and without metadata as a tree" do
+      PuppetSpec::Modules.create('nometadata', @modpath1)
+      PuppetSpec::Modules.create('metadata', @modpath1, :metadata => {:author => 'metaman'})
+
+      expected = <<-HEREDOC.gsub('        ', '')
+        #{@modpath1}
+        ├── metaman-metadata (\e[0;36mv9.9.9\e[0m)
+        └── nometadata (\e[0;36m???\e[0m)
+        #{@modpath2} (no modules installed)
+      HEREDOC
+
+      console_output.should == expected
+    end
+
+    it "should warn about missing dependencies" do
+      PuppetSpec::Modules.create('depender', @modpath1, :metadata => {
+        :version => '1.0.0',
+        :dependencies => [{
+          "version_requirement" => ">= 0.0.5",
+          "name"                => "puppetlabs/dependable"
+        }]
+      })
+
+      warning_expectations = [
+        regexp_matches(/Missing dependency 'puppetlabs-dependable'/),
+        regexp_matches(/'puppetlabs-depender' \(v1\.0\.0\) requires 'puppetlabs-dependable' \(>= 0\.0\.5\)/)
+      ]
+
+      Puppet.expects(:warning).with(all_of(*warning_expectations))
+
+      console_output(:tree => true)
+    end
+
+    it "should warn about out of range dependencies" do
+      PuppetSpec::Modules.create('dependable', @modpath1, :metadata => { :version => '0.0.1'})
+      PuppetSpec::Modules.create('depender', @modpath1, :metadata => {
+        :version => '1.0.0',
+        :dependencies => [{
+          "version_requirement" => ">= 0.0.5",
+          "name"                => "puppetlabs/dependable"
+        }]
+      })
+
+      warning_expectations = [
+        regexp_matches(/Module 'puppetlabs-dependable' \(v0\.0\.1\) fails to meet some dependencies/),
+        regexp_matches(/'puppetlabs-depender' \(v1\.0\.0\) requires 'puppetlabs-dependable' \(>= 0\.0\.5\)/)
+      ]
+
+      Puppet.expects(:warning).with(all_of(*warning_expectations))
+
+      console_output(:tree => true)
     end
   end
 end