puppet 2.7.13 → 2.7.14

data/spec/unit/agent_spec.rb

@@ -270,36 +270,4 @@ describe Puppet::Agent do
       end
     end
   end
-
-  describe "when starting" do
-    before do
-      @agent.stubs(:observe_signal)
-    end
-
-    it "should create a timer with the runinterval, a tolerance of 1, and :start? set to true" do
-      Puppet.settings.expects(:value).with(:runinterval).returns 5
-      timer = stub 'timer', :sound_alarm => nil
-      EventLoop::Timer.expects(:new).with(:interval => 5, :start? => true, :tolerance => 1).returns timer
-
-      @agent.stubs(:run)
-      @agent.start
-    end
-
-    it "should run once immediately" do
-      timer = mock 'timer'
-      EventLoop::Timer.expects(:new).returns timer
-
-      timer.expects(:sound_alarm)
-
-      @agent.start
-    end
-
-    it "should run within the block passed to the timer" do
-      timer = stub 'timer', :sound_alarm => nil
-      EventLoop::Timer.expects(:new).returns(timer).yields
-      @agent.expects(:run)
-
-      @agent.start
-    end
-  end
 end

data/spec/unit/application/kick_spec.rb

@@ -239,14 +239,14 @@ describe Puppet::Application::Kick, :if => Puppet.features.posix? do
         @kick.hosts = ['host1', 'host2', 'host3']
         Process.stubs(:wait).returns(1).then.returns(2).then.returns(3).then.raises(Errno::ECHILD)
 
-        @kick.expects(:fork).times(3).returns(1).then.returns(2).then.returns(3)
+        @kick.expects(:safe_posix_fork).times(3).returns(1).then.returns(2).then.returns(3)
 
         expect { @kick.main }.to raise_error SystemExit
       end
 
       it "should delegate to run_for_host per host" do
         @kick.hosts = ['host1', 'host2']
-        @kick.stubs(:fork).returns(1).yields
+        @kick.stubs(:safe_posix_fork).returns(1).yields
         Process.stubs(:wait).returns(1).then.raises(Errno::ECHILD)
 
         @kick.expects(:run_for_host).times(2)

data/spec/unit/daemon_spec.rb

@@ -49,7 +49,7 @@ describe Puppet::Daemon do
     before do
       @daemon.stubs(:create_pidfile)
       @daemon.stubs(:set_signal_traps)
-      EventLoop.current.stubs(:run)
+      @daemon.stubs(:run_event_loop)
     end
 
     it "should fail if it has neither agent nor server" do
@@ -58,19 +58,10 @@ describe Puppet::Daemon do
 
     it "should create its pidfile" do
       @daemon.stubs(:agent).returns stub('agent', :start => nil)
-
       @daemon.expects(:create_pidfile)
       @daemon.start
     end
 
-    it "should start the agent if the agent is configured" do
-      agent = mock 'agent'
-      agent.expects(:start)
-      @daemon.stubs(:agent).returns agent
-
-      @daemon.start
-    end
-
     it "should start its server if one is configured" do
       server = mock 'server'
       server.expects(:start)
@@ -78,13 +69,6 @@ describe Puppet::Daemon do
 
       @daemon.start
     end
-
-    it "should let the current EventLoop run" do
-      @daemon.stubs(:agent).returns stub('agent', :start => nil)
-      EventLoop.current.expects(:run)
-
-      @daemon.start
-    end
   end
 
   describe "when stopping" do

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

@@ -0,0 +1,158 @@
+require 'spec_helper'
+require 'puppet/face'
+require 'puppet/module_tool'
+
+describe "puppet module install" do
+
+  subject { Puppet::Face[:module, :current] }
+
+  let(:options) do
+    {}
+  end
+
+  describe "option validation" do
+    before do
+      Puppet.settings[:modulepath] = fakemodpath
+    end
+
+    let(:expected_options) do
+      {
+        :target_dir  => fakefirstpath,
+        :modulepath  => fakemodpath,
+        :environment => 'production'
+      }
+    end
+
+    let(:sep) { File::PATH_SEPARATOR }
+    let(:fakefirstpath)  { "/my/fake/modpath" }
+    let(:fakesecondpath) { "/other/fake/path" }
+    let(:fakemodpath)    { "#{fakefirstpath}#{sep}#{fakesecondpath}" }
+    let(:fakedirpath)    { "/my/fake/path" }
+
+    context "without any options" do
+      it "should require a name" do
+        pattern = /wrong number of arguments/
+        expect { subject.install }.to raise_error ArgumentError, pattern
+      end
+
+      it "should not require any options" do
+        Puppet::ModuleTool::Applications::Installer.expects(:run).with("puppetlabs-apache", expected_options).once
+        subject.install("puppetlabs-apache")
+      end
+    end
+
+    it "should accept the --force option" do
+      options[:force] = true
+      expected_options.merge!(options)
+      Puppet::ModuleTool::Applications::Installer.expects(:run).with("puppetlabs-apache", expected_options).once
+      subject.install("puppetlabs-apache", options)
+    end
+
+    it "should accept the --target-dir option" do
+      options[:target_dir] = "/foo/puppet/modules"
+      expected_options.merge!(options)
+      expected_options[:modulepath] = "#{options[:target_dir]}#{sep}#{fakemodpath}"
+
+      Puppet::ModuleTool::Applications::Installer.expects(:run).with("puppetlabs-apache", expected_options).once
+      subject.install("puppetlabs-apache", options)
+    end
+
+    it "should accept the --version option" do
+      options[:version] = "0.0.1"
+      expected_options.merge!(options)
+      Puppet::ModuleTool::Applications::Installer.expects(:run).with("puppetlabs-apache", expected_options).once
+      subject.install("puppetlabs-apache", options)
+    end
+
+    it "should accept the --ignore-dependencies option" do
+      options[:ignore_dependencies] = true
+      expected_options.merge!(options)
+      Puppet::ModuleTool::Applications::Installer.expects(:run).with("puppetlabs-apache", expected_options).once
+      subject.install("puppetlabs-apache", options)
+    end
+
+    describe "when modulepath option is passed" do
+      let(:expected_options) { { :modulepath => fakemodpath, :environment => 'production' } }
+      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
+
+          Puppet::ModuleTool::Applications::Installer.
+            expects(:run).
+            with("puppetlabs-apache", expected_options)
+
+          Puppet::Face[:module, :current].install("puppetlabs-apache", options)
+
+          Puppet.settings[:modulepath].should == fakemodpath
+        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}"
+
+          Puppet::ModuleTool::Applications::Installer.
+            expects(: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
+
+          Puppet::ModuleTool::Applications::Installer.
+            expects(: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}"
+
+          Puppet::ModuleTool::Applications::Installer.
+            expects(:run).
+            with("puppetlabs-apache", expected_options)
+
+          Puppet::Face[:module, :current].install("puppetlabs-apache", options)
+          Puppet.settings[:modulepath].should == expected_options[:modulepath]
+        end
+      end
+    end
+  end
+
+  describe "inline documentation" do
+    subject { Puppet::Face[:module, :current].get_action :install }
+
+    its(:summary)     { should =~ /install.*module/im }
+    its(:description) { should =~ /install.*module/im }
+    its(:returns)     { should =~ /pathname/i }
+    its(:examples)    { should_not be_empty }
+
+    %w{ license copyright summary description returns examples }.each do |doc|
+      context "of the" do
+        its(doc.to_sym) { should_not =~ /(FIXME|REVISIT|TODO)/ }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,182 @@
+# encoding: UTF-8
+
+require 'spec_helper'
+require 'puppet/face'
+require 'puppet/module_tool'
+require 'puppet_spec/modules'
+
+describe "puppet module list", :fails_on_windows => true do
+  include PuppetSpec::Files
+
+  before do
+    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
+
+  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 == {
+      @modpath1 => [],
+      @modpath2 => []
+    }
+  end
+
+  it "should include modules separated by the environment's modulepath" do
+    foomod1 = PuppetSpec::Modules.create('foo', @modpath1)
+    barmod1 = PuppetSpec::Modules.create('bar', @modpath1)
+    foomod2 = PuppetSpec::Modules.create('foo', @modpath2)
+
+    env = Puppet::Node::Environment.new
+
+    Puppet::Face[:module, :current].list.should == {
+      @modpath1 => [
+        Puppet::Module.new('bar', :environment => env, :path => barmod1.path),
+        Puppet::Module.new('foo', :environment => env, :path => foomod1.path)
+      ],
+      @modpath2 => [Puppet::Module.new('foo', :environment => env, :path => foomod2.path)]
+    }
+  end
+
+  it "should use the specified environment" do
+    PuppetSpec::Modules.create('foo', @modpath1)
+    PuppetSpec::Modules.create('bar', @modpath1)
+
+    usedenv = Puppet::Node::Environment.new('useme')
+    usedenv.modulepath = [@modpath1, @modpath2]
+
+    Puppet::Face[:module, :current].list(:environment => 'useme').should == {
+      @modpath1 => [
+        Puppet::Module.new('bar', :environment => usedenv),
+        Puppet::Module.new('foo', :environment => usedenv)
+      ],
+      @modpath2 => []
+    }
+  end
+
+  it "should use the specified modulepath" do
+    PuppetSpec::Modules.create('foo', @modpath1)
+    PuppetSpec::Modules.create('bar', @modpath2)
+
+    Puppet::Face[:module, :current].list(:modulepath => "#{@modpath1}#{File::PATH_SEPARATOR}#{@modpath2}").should == {
+      @modpath1 => [ Puppet::Module.new('foo') ],
+      @modpath2 => [ Puppet::Module.new('bar') ]
+    }
+  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', :environment => env, :path => foomod1.path) ],
+      @modpath2 => [ Puppet::Module.new('bar', :environment => env, :path => barmod2.path) ]
+    }
+  end
+
+  describe "inline documentation" do
+    subject { Puppet::Face[:module, :current].get_action :list }
+
+    its(:summary)     { should =~ /list.*module/im }
+    its(:description) { should =~ /list.*module/im }
+    its(:returns)     { should =~ /hash of paths to module objects/i }
+    its(:examples)    { should_not be_empty }
+  end
+
+  describe "when rendering" do
+    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('        ', '')
+        #{empty_modpath} (no modules installed)
+      HEREDOC
+    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)
+      HEREDOC
+    end
+
+    it "should print the modulepaths in the order they are in the modulepath setting" do
+      path1 = tmpdir('b')
+      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
+    end
+
+    it "should print dependencies as a tree" do
+      PuppetSpec::Modules.create('dependable', @modpath1, :metadata => { :version => '0.0.5'})
+      PuppetSpec::Modules.create(
+        'other_mod',
+        @modpath1,
+        :metadata => {
+          :version => '1.0.0',
+          :dependencies => [{
+            "version_requirement" => ">= 0.0.5",
+            "name"                => "puppetlabs/dependable"
+          }]
+        }
+      )
+
+      dependency_tree = Puppet::Face[:module, :current].list
+
+      output = Puppet::Face[:module, :current].list_when_rendering_console(
+        dependency_tree,
+        {:tree => true}
+      )
+
+      output.should == <<-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
+    end
+  end
+
+end

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

@@ -0,0 +1,163 @@
+require 'spec_helper'
+require 'puppet/face'
+require 'puppet/application/module'
+require 'puppet/module_tool'
+
+describe "puppet module search", :fails_on_windows => true do
+  subject { Puppet::Face[:module, :current] }
+
+  let(:options) do
+    {}
+  end
+
+  describe Puppet::Application::Module do
+    subject do
+      app = Puppet::Application::Module.new
+      app.stubs(:action).returns(Puppet::Face.find_action(:module, :search))
+      app
+    end
+
+    before { subject.render_as = :console }
+    before { Puppet::Util::Terminal.stubs(:width).returns(100) }
+
+    it 'should output nothing when receiving an empty dataset' do
+      subject.render([], ['apache', {}]).should == "No results found for 'apache'."
+    end
+
+    it 'should output a header when receiving a non-empty dataset' do
+      results = [
+        {'full_name' => '', 'author' => '', 'desc' => '', 'tag_list' => [] },
+      ]
+
+      subject.render(results, ['apache', {}]).should =~ /NAME/
+      subject.render(results, ['apache', {}]).should =~ /DESCRIPTION/
+      subject.render(results, ['apache', {}]).should =~ /AUTHOR/
+      subject.render(results, ['apache', {}]).should =~ /KEYWORDS/
+    end
+
+    it 'should output the relevant fields when receiving a non-empty dataset' do
+      results = [
+        {'full_name' => 'Name', 'author' => 'Author', 'desc' => 'Summary', 'tag_list' => ['tag1', 'tag2'] },
+      ]
+
+      subject.render(results, ['apache', {}]).should =~ /Name/
+      subject.render(results, ['apache', {}]).should =~ /Author/
+      subject.render(results, ['apache', {}]).should =~ /Summary/
+      subject.render(results, ['apache', {}]).should =~ /tag1/
+      subject.render(results, ['apache', {}]).should =~ /tag2/
+    end
+
+    it 'should elide really long descriptions' do
+      results = [
+        {
+          'full_name' => 'Name',
+          'author' => 'Author',
+          'desc' => 'This description is really too long to fit in a single data table, guys -- we should probably set about truncating it',
+          'tag_list' => ['tag1', 'tag2'],
+        },
+      ]
+
+      subject.render(results, ['apache', {}]).should =~ /\.{3}  @Author/
+    end
+
+    it 'should never truncate the module name' do
+      results = [
+        {
+          'full_name' => 'This-module-has-a-really-really-long-name',
+          'author' => 'Author',
+          'desc' => 'Description',
+          'tag_list' => ['tag1', 'tag2'],
+        },
+      ]
+
+      subject.render(results, ['apache', {}]).should =~ /This-module-has-a-really-really-long-name/
+    end
+
+    it 'should never truncate the author name' do
+      results = [
+        {
+          'full_name' => 'Name',
+          'author' => 'This-author-has-a-really-really-long-name',
+          'desc' => 'Description',
+          'tag_list' => ['tag1', 'tag2'],
+        },
+      ]
+
+      subject.render(results, ['apache', {}]).should =~ /@This-author-has-a-really-really-long-name/
+    end
+
+    it 'should never remove tags that match the search term' do
+      results = [
+        {
+          'full_name' => 'Name',
+          'author' => 'Author',
+          'desc' => 'Description',
+          'tag_list' => ['Supercalifragilisticexpialidocious'] + (1..100).map { |i| "tag#{i}" },
+        },
+      ]
+
+      subject.render(results, ['Supercalifragilisticexpialidocious', {}]).should =~ /Supercalifragilisticexpialidocious/
+      subject.render(results, ['Supercalifragilisticexpialidocious', {}]).should_not =~ /tag/
+    end
+
+    {
+      100 => "NAME          DESCRIPTION                                     AUTHOR         KEYWORDS#{' '*15}\n"\
+             "Name          This description is really too long to fit ...  @JohnnyApples  tag1 tag2 taggitty3#{' '*4}\n",
+
+      70  => "NAME          DESCRIPTION                 AUTHOR         KEYWORDS#{' '*5}\n"\
+             "Name          This description is rea...  @JohnnyApples  tag1 tag2#{' '*4}\n",
+
+      80  => "NAME          DESCRIPTION                        AUTHOR         KEYWORDS#{' '*8}\n"\
+             "Name          This description is really too...  @JohnnyApples  tag1 tag2#{' '*7}\n",
+
+      200 => "NAME          DESCRIPTION                                                                                                        AUTHOR         KEYWORDS#{' '*48}\n"\
+             "Name          This description is really too long to fit in a single data table, guys -- we should probably set about trunca...  @JohnnyApples  tag1 tag2 taggitty3#{' '*37}\n"
+    }.each do |width, expectation|
+      it "should resize the table to fit the screen, when #{width} columns" do
+        results = [
+          {
+            'full_name' => 'Name',
+            'author' => 'JohnnyApples',
+            'desc' => 'This description is really too long to fit in a single data table, guys -- we should probably set about truncating it',
+            'tag_list' => ['tag1', 'tag2', 'taggitty3'],
+          },
+        ]
+
+        Puppet::Util::Terminal.expects(:width).returns(width)
+        result = subject.render(results, ['apache', {}])
+        result.lines.sort_by(&:length).last.chomp.length.should <= width
+        result.should == expectation
+      end
+    end
+  end
+
+  describe "option validation" do
+    context "without any options" do
+      it "should require a search term" do
+        pattern = /wrong number of arguments/
+        expect { subject.search }.to raise_error ArgumentError, pattern
+      end
+    end
+
+    it "should accept the --module-repository option" do
+      options[:module_repository] = "http://forge.example.com"
+      Puppet::ModuleTool::Applications::Searcher.expects(:run).with("puppetlabs-apache", options).once
+      subject.search("puppetlabs-apache", options)
+    end
+  end
+
+  describe "inline documentation" do
+    subject { Puppet::Face[:module, :current].get_action :search }
+
+    its(:summary)     { should =~ /search.*module/im }
+    its(:description) { should =~ /search.*module/im }
+    its(:returns)     { should =~ /array/i }
+    its(:examples)    { should_not be_empty }
+
+    %w{ license copyright summary description returns examples }.each do |doc|
+      context "of the" do
+        its(doc.to_sym) { should_not =~ /(FIXME|REVISIT|TODO)/ }
+      end
+    end
+  end
+end