puppet 2.7.9 → 2.7.11

data/spec/unit/indirector/instrumentation_data/rest_spec.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+
+require 'puppet/util/instrumentation/data'
+require 'puppet/indirector/instrumentation_data/rest'
+
+describe Puppet::Indirector::InstrumentationData::Rest do
+  it "should be a subclass of Puppet::Indirector::REST" do
+    Puppet::Indirector::InstrumentationData::Rest.superclass.should equal(Puppet::Indirector::REST)
+  end
+end

data/spec/unit/indirector/instrumentation_listener/local_spec.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+
+require 'puppet/util/instrumentation/listener'
+require 'puppet/indirector/instrumentation_listener/local'
+
+describe Puppet::Indirector::InstrumentationListener::Local do
+  it "should be a subclass of the Code terminus" do
+    Puppet::Indirector::InstrumentationListener::Local.superclass.should equal(Puppet::Indirector::Code)
+  end
+
+  it "should be registered with the configuration store indirection" do
+    indirection = Puppet::Indirector::Indirection.instance(:instrumentation_listener)
+    Puppet::Indirector::InstrumentationListener::Local.indirection.should equal(indirection)
+  end
+
+  it "should have its name set to :local" do
+    Puppet::Indirector::InstrumentationListener::Local.name.should == :local
+  end
+end
+
+describe Puppet::Indirector::InstrumentationListener::Local do
+  before :each do
+    Puppet::Util::Instrumentation.stubs(:listener)
+    @listener = Puppet::Indirector::InstrumentationListener::Local.new
+    @name = "me"
+    @request = stub 'request', :key => @name
+  end
+
+  describe "when finding listeners" do
+    it "should return a Instrumentation Listener instance matching the key" do
+      Puppet::Util::Instrumentation.expects(:[]).with("me").returns(:instance)
+      @listener.find(@request).should == :instance
+    end
+  end
+
+  describe "when searching listeners" do
+    it "should return a list of all loaded Instrumentation Listenesrs irregardless of the given key" do
+      Puppet::Util::Instrumentation.expects(:listeners).returns([:instance1, :instance2])
+      @listener.search(@request).should == [:instance1, :instance2]
+    end
+  end
+
+  describe "when saving listeners" do
+    it "should set the new listener to the global listener list" do
+      newlistener = stub 'listener', :name => @name
+      @request.stubs(:instance).returns(newlistener)
+      Puppet::Util::Instrumentation.expects(:[]=).with("me", newlistener)
+      @listener.save(@request)
+    end
+  end
+
+  describe "when destroying listeners" do
+    it "should raise an error if listener wasn't subscribed" do
+      Puppet::Util::Instrumentation.expects(:[]).with("me").returns(nil)
+      lambda { @listener.destroy(@request) }.should raise_error
+    end
+
+    it "should unsubscribe the listener" do
+      Puppet::Util::Instrumentation.expects(:[]).with("me").returns(:instancce)
+      Puppet::Util::Instrumentation.expects(:unsubscribe).with(:instancce)
+      @listener.destroy(@request)
+    end
+  end
+end

data/spec/unit/indirector/instrumentation_listener/rest_spec.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+
+require 'puppet/util/instrumentation/listener'
+require 'puppet/indirector/instrumentation_listener/rest'
+
+describe Puppet::Indirector::InstrumentationListener::Rest do
+  it "should be a subclass of Puppet::Indirector::REST" do
+    Puppet::Indirector::InstrumentationListener::Rest.superclass.should equal(Puppet::Indirector::REST)
+  end
+end

data/spec/unit/indirector/instrumentation_probe/local_spec.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+
+require 'puppet/util/instrumentation/indirection_probe'
+require 'puppet/indirector/instrumentation_probe/local'
+require 'puppet/util/instrumentation/instrumentable'
+
+describe Puppet::Indirector::InstrumentationProbe::Local do
+  it "should be a subclass of the Code terminus" do
+    Puppet::Indirector::InstrumentationProbe::Local.superclass.should equal(Puppet::Indirector::Code)
+  end
+
+  it "should be registered with the configuration store indirection" do
+    indirection = Puppet::Indirector::Indirection.instance(:instrumentation_probe)
+    Puppet::Indirector::InstrumentationProbe::Local.indirection.should equal(indirection)
+  end
+
+  it "should have its name set to :local" do
+    Puppet::Indirector::InstrumentationProbe::Local.name.should == :local
+  end
+end
+
+describe Puppet::Indirector::InstrumentationProbe::Local do
+  before :each do
+    Puppet::Util::Instrumentation.stubs(:listener)
+    @probe = Puppet::Indirector::InstrumentationProbe::Local.new
+    @name = "me"
+    @request = stub 'request', :key => @name
+  end
+
+  describe "when finding probes" do
+    it "should do nothing" do
+      @probe.find(@request).should be_nil
+    end
+  end
+
+  describe "when searching probes" do
+    it "should return a list of all loaded probes irregardless of the given key" do
+      instance1 = stub 'instance1', :method => "probe1", :klass => "Klass1"
+      instance2 = stub 'instance2', :method => "probe2", :klass => "Klass2"
+      Puppet::Util::Instrumentation::IndirectionProbe.expects(:new).with("Klass1.probe1").returns(:instance1)
+      Puppet::Util::Instrumentation::IndirectionProbe.expects(:new).with("Klass2.probe2").returns(:instance2)
+      Puppet::Util::Instrumentation::Instrumentable.expects(:each_probe).multiple_yields([instance1], [instance2])
+      @probe.search(@request).should == [ :instance1, :instance2 ]
+    end
+  end
+
+  describe "when saving probes" do
+    it "should enable probes" do
+      newprobe = stub 'probe', :name => @name
+      @request.stubs(:instance).returns(newprobe)
+      Puppet::Util::Instrumentation::Instrumentable.expects(:enable_probes)
+      @probe.save(@request)
+    end
+  end
+
+  describe "when destroying probes" do
+    it "should disable probes" do
+      newprobe = stub 'probe', :name => @name
+      @request.stubs(:instance).returns(newprobe)
+      Puppet::Util::Instrumentation::Instrumentable.expects(:disable_probes)
+      @probe.destroy(@request)
+    end
+  end
+end

data/spec/unit/indirector/instrumentation_probe/rest_spec.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+
+require 'puppet/util/instrumentation/indirection_probe'
+require 'puppet/indirector/instrumentation_probe/rest'
+
+describe Puppet::Indirector::InstrumentationProbe::Rest do
+  it "should be a subclass of Puppet::Indirector::REST" do
+    Puppet::Indirector::InstrumentationProbe::Rest.superclass.should equal(Puppet::Indirector::REST)
+  end
+end

data/spec/unit/module_spec.rb

@@ -89,83 +89,6 @@ describe Puppet::Module do
     lambda { mod.validate_puppet_version }.should raise_error(Puppet::Module::IncompatibleModule)
   end
 
-  describe "when specifying required modules" do
-    it "should support specifying a required module" do
-      mod = Puppet::Module.new("mymod")
-      mod.requires "foobar"
-    end
-
-    it "should support specifying multiple required modules" do
-      mod = Puppet::Module.new("mymod")
-      mod.requires "foobar"
-      mod.requires "baz"
-    end
-
-    it "should support specifying a required module and version" do
-      mod = Puppet::Module.new("mymod")
-      mod.requires "foobar", 1.0
-    end
-
-    it "should fail when required modules are missing" do
-      mod = Puppet::Module.new("mymod")
-      mod.requires "foobar"
-
-      mod.environment.expects(:module).with("foobar").returns nil
-
-      lambda { mod.validate_dependencies }.should raise_error(Puppet::Module::MissingModule)
-    end
-
-    it "should fail when required modules are present but of the wrong version" do
-      mod = Puppet::Module.new("mymod")
-      mod.requires "foobar", 1.0
-
-      foobar = Puppet::Module.new("foobar")
-      foobar.version = 2.0
-
-      mod.environment.expects(:module).with("foobar").returns foobar
-
-      lambda { mod.validate_dependencies }.should raise_error(Puppet::Module::IncompatibleModule)
-    end
-
-    it "should have valid dependencies when no dependencies have been specified" do
-      mod = Puppet::Module.new("mymod")
-
-      lambda { mod.validate_dependencies }.should_not raise_error
-    end
-
-    it "should fail when some dependencies are present but others aren't" do
-      mod = Puppet::Module.new("mymod")
-      mod.requires "foobar"
-      mod.requires "baz"
-
-      mod.environment.expects(:module).with("foobar").returns Puppet::Module.new("foobar")
-      mod.environment.expects(:module).with("baz").returns nil
-
-      lambda { mod.validate_dependencies }.should raise_error(Puppet::Module::MissingModule)
-    end
-
-    it "should have valid dependencies when all dependencies are met" do
-      mod = Puppet::Module.new("mymod")
-      mod.requires "foobar", 1.0
-      mod.requires "baz"
-
-      foobar = Puppet::Module.new("foobar")
-      foobar.version = 1.0
-
-      baz = Puppet::Module.new("baz")
-
-      mod.environment.expects(:module).with("foobar").returns foobar
-      mod.environment.expects(:module).with("baz").returns baz
-
-      lambda { mod.validate_dependencies }.should_not raise_error
-    end
-
-    it "should validate its dependendencies on initialization" do
-      Puppet::Module.any_instance.expects(:validate_dependencies)
-      Puppet::Module.new("mymod")
-    end
-  end
-
   describe "when managing supported platforms" do
     it "should support specifying a supported platform" do
       mod = Puppet::Module.new("mymod")
@@ -251,11 +174,11 @@ describe Puppet::Module do
   end
 
   it "should convert an environment name into an Environment instance" do
-    Puppet::Module.new("foo", "prod").environment.should be_instance_of(Puppet::Node::Environment)
+    Puppet::Module.new("foo", :environment => "prod").environment.should be_instance_of(Puppet::Node::Environment)
   end
 
   it "should accept an environment at initialization" do
-    Puppet::Module.new("foo", :prod).environment.name.should == :prod
+    Puppet::Module.new("foo", :environment => :prod).environment.name.should == :prod
   end
 
   it "should use the default environment if none is provided" do
@@ -265,43 +188,53 @@ describe Puppet::Module do
 
   it "should use any provided Environment instance" do
     env = Puppet::Node::Environment.new
-    Puppet::Module.new("foo", env).environment.should equal(env)
+    Puppet::Module.new("foo", :environment => env).environment.should equal(env)
   end
 
-  it "should return the path to the first found instance in its environment's module paths as its path" do
-    dir = tmpdir("deep_path")
-    first = File.join(dir, "first")
-    second = File.join(dir, "second")
+  describe ".path" do
+    before do
+      dir = tmpdir("deep_path")
 
-    FileUtils.mkdir_p(first)
-    FileUtils.mkdir_p(second)
-    Puppet[:modulepath] = "#{first}#{File::PATH_SEPARATOR}#{second}"
+      @first = File.join(dir, "first")
+      @second = File.join(dir, "second")
+      Puppet[:modulepath] = "#{@first}#{File::PATH_SEPARATOR}#{@second}"
 
-    modpath = File.join(first, "foo")
-    FileUtils.mkdir_p(modpath)
+      FileUtils.mkdir_p(@first)
+      FileUtils.mkdir_p(@second)
+    end
 
-    # Make a second one, which we shouldn't find
-    FileUtils.mkdir_p(File.join(second, "foo"))
+    it "should return the path to the first found instance in its environment's module paths as its path" do
+      modpath = File.join(@first, "foo")
+      FileUtils.mkdir_p(modpath)
 
-    mod = Puppet::Module.new("foo")
-    mod.path.should == modpath
-  end
+      # Make a second one, which we shouldn't find
+      FileUtils.mkdir_p(File.join(@second, "foo"))
+
+      mod = Puppet::Module.new("foo")
+      mod.path.should == modpath
+    end
 
-  it "should be able to find itself in a directory other than the first directory in the module path" do
-    dir = tmpdir("deep_path")
-    first = File.join(dir, "first")
-    second = File.join(dir, "second")
+    it "should be able to find itself in a directory other than the first directory in the module path" do
+      modpath = File.join(@second, "foo")
+      FileUtils.mkdir_p(modpath)
 
-    FileUtils.mkdir_p(first)
-    FileUtils.mkdir_p(second)
-    Puppet[:modulepath] = "#{first}#{File::PATH_SEPARATOR}#{second}"
+      mod = Puppet::Module.new("foo")
+      mod.should be_exist
+      mod.path.should == modpath
+    end
 
-    modpath = File.join(second, "foo")
-    FileUtils.mkdir_p(modpath)
+    it "should be able to find itself in a directory other than the first directory in the module path even when it exists in the first" do
+      environment = Puppet::Node::Environment.new
 
-    mod = Puppet::Module.new("foo")
-    mod.should be_exist
-    mod.path.should == modpath
+      first_modpath = File.join(@first, "foo")
+      FileUtils.mkdir_p(first_modpath)
+      second_modpath = File.join(@second, "foo")
+      FileUtils.mkdir_p(second_modpath)
+
+      mod = Puppet::Module.new("foo", :environment => environment, :path => second_modpath)
+      mod.path.should == File.join(@second, "foo")
+      mod.environment.should == environment
+    end
   end
 
   it "should be considered existent if it exists in at least one module path" do
@@ -403,24 +336,6 @@ describe Puppet::Module do
   end
 end
 
-describe Puppet::Module, " when building its search path" do
-  it "should use the current environment's search path if no environment is specified" do
-    env = mock 'env'
-    env.expects(:modulepath).returns "eh"
-    Puppet::Node::Environment.expects(:new).with(nil).returns env
-
-    Puppet::Module.modulepath.should == "eh"
-  end
-
-  it "should use the specified environment's search path if an environment is specified" do
-    env = mock 'env'
-    env.expects(:modulepath).returns "eh"
-    Puppet::Node::Environment.expects(:new).with("foo").returns env
-
-    Puppet::Module.modulepath("foo").should == "eh"
-  end
-end
-
 describe Puppet::Module, "when finding matching manifests" do
   before do
     @mod = Puppet::Module.new("mymod")
@@ -592,7 +507,6 @@ describe Puppet::Module do
       @module.puppetversion.should == @data[:puppetversion]
     end
 
-
     it "should fail if the discovered name is different than the metadata name"
   end
 end

data/spec/unit/module_tool/uninstaller_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'puppet/module_tool'
+require 'tmpdir'
+
+describe Puppet::Module::Tool::Applications::Uninstaller do
+  include PuppetSpec::Files
+
+  describe "instances" do
+    let(:tmp_module_path1) { tmpdir("uninstaller_module_path1") }
+    let(:tmp_module_path2) { tmpdir("uninstaller_module_path2") }
+    let(:options) do
+      { :target_directories => [ tmp_module_path1, tmp_module_path2 ] }
+    end
+
+    it "should return an empty list if the module is not installed" do
+      described_class.new('foo', options).run.should == []
+    end
+
+    it "should uninstall an installed module" do
+      foo_module_path = File.join(tmp_module_path1, 'foo')
+      Dir.mkdir(foo_module_path)
+      described_class.new('foo', options).run.should == [ foo_module_path ]
+    end
+
+    it "should only uninstall the requested module" do
+      foo_module_path = File.join(tmp_module_path1, 'foo')
+      bar_module_path = File.join(tmp_module_path1, 'bar')
+      Dir.mkdir(foo_module_path)
+      Dir.mkdir(bar_module_path)
+      described_class.new('foo', options).run.should == [ foo_module_path ]
+    end
+
+    it "should uninstall the module from all target directories" do
+      foo1_module_path = File.join(tmp_module_path1, 'foo')
+      foo2_module_path = File.join(tmp_module_path2, 'foo')
+      Dir.mkdir(foo1_module_path)
+      Dir.mkdir(foo2_module_path)
+      described_class.new('foo', options).run.should == [ foo1_module_path, foo2_module_path ]
+    end
+
+    #11803
+    it "should check for broken dependencies"
+  end
+end

data/spec/unit/network/server_spec.rb

@@ -196,36 +196,18 @@ describe Puppet::Network::Server do
     end
 
     it "should do nothing if the pidfile is not present" do
-      pidfile = mock 'pidfile', :locked? => false
+      pidfile = mock 'pidfile', :unlock => false
       Puppet::Util::Pidlock.expects(:new).with("/my/file").returns pidfile
-
-      Puppet.settings.stubs(:value).with(:name).returns "eh"
       Puppet.settings.stubs(:value).with(:pidfile).returns "/my/file"
 
-      pidfile.expects(:unlock).never
       @server.remove_pidfile
     end
 
     it "should unlock the pidfile using the Pidlock class" do
-      pidfile = mock 'pidfile', :locked? => true
-      Puppet::Util::Pidlock.expects(:new).with("/my/file").returns pidfile
-      pidfile.expects(:unlock).returns true
-
-      Puppet.settings.stubs(:value).with(:name).returns "eh"
-      Puppet.settings.stubs(:value).with(:pidfile).returns "/my/file"
-
-      @server.remove_pidfile
-    end
-
-    it "should warn if it cannot remove the pidfile" do
-      pidfile = mock 'pidfile', :locked? => true
+      pidfile = mock 'pidfile', :unlock => true
       Puppet::Util::Pidlock.expects(:new).with("/my/file").returns pidfile
-      pidfile.expects(:unlock).returns false
-
-      Puppet.settings.stubs(:value).with(:name).returns "eh"
       Puppet.settings.stubs(:value).with(:pidfile).returns "/my/file"
 
-      Puppet.expects :err
       @server.remove_pidfile
     end
   end