From 02b311113df84646406737ccfad961c5b6df4ae8 Mon Sep 17 00:00:00 2001
From: Stefan Schulte <stefan.schulte@taunusstein.net>
Date: Thu, 23 Dec 2010 18:08:37 +0100
Subject: (#5605) Prefetch doesnt work with composite keys

The uniqueness_key method of a type or resource object should return a
key that can be used to identify this resource. In fact puppet seldomly
uses this method and instead uses resource[:name] as an identifier.

While this is totally fine for resourcetypes with a single
key_attribute (and resource[:name] returning the namevar), it breaks
things as soon as one creates a type with a composite key (prefetching
for example is broken). To ease the process of replacing calls to
resource[:name] to resource.uniqueness_key, the method uniqueness_key now
just returns name_var if there is only one key_attribute (immitating
self[:name]) and only returns an array of all the values of all the
key_attributes if we have more than one key_attribute.

The resourcehash which is passed to providers in their prefetch method
is now build with uniqueness_key as the hashkey. Because of the new
behaviour of uniqueness_key we hopefully wont break existing providers
while allowing new providers for types with composite keys to implement
correct prefetch methods.
---
 spec/unit/resource_spec.rb | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

(limited to 'spec')

diff --git a/spec/unit/resource_spec.rb b/spec/unit/resource_spec.rb
index e65e8a13a..092ae8ce0 100755
--- a/spec/unit/resource_spec.rb
+++ b/spec/unit/resource_spec.rb
@@ -268,7 +268,7 @@ describe Puppet::Resource do
   describe "when referring to a resource with name canonicalization" do
     it "should canonicalize its own name" do
       res = Puppet::Resource.new("file", "/path/")
-      res.uniqueness_key.should == ["/path"]
+      res.uniqueness_key.should == "/path"
       res.ref.should == "File[/path/]"
     end
   end
@@ -770,7 +770,14 @@ describe Puppet::Resource do
   end
 
   describe "when generating the uniqueness key" do
-    it "should include all of the key_attributes in alphabetical order by attribute name" do
+
+    it "should use namevar if there is only one key_attribute" do
+      Puppet::Type.type(:file).stubs(:key_attributes).returns [:path]
+      res = Puppet::Resource.new("file", "/my/file", :parameters => {:owner => 'root', :content => 'hello'})
+      res.uniqueness_key.should == '/my/file'
+    end
+
+    it "should include all of the key_attributes" do
       Puppet::Type.type(:file).stubs(:key_attributes).returns [:myvar, :owner, :path]
       Puppet::Type.type(:file).stubs(:title_patterns).returns(
         [ [ /(.*)/, [ [:path, lambda{|x| x} ] ] ] ]
-- 
cgit 


From 8b98526b0f81d559fdf85fc8aaf370f75baa5919 Mon Sep 17 00:00:00 2001
From: Stefan Schulte <stefan.schulte@taunusstein.net>
Date: Thu, 23 Dec 2010 22:11:49 +0100
Subject: (#5662) Fixed tests that didnt stub key_attributes

The parsedfile provider calls the method key_attributes of the resource
class to decide what resourceparameters must be put in the
property_hash. Tests that uses fake resources and only stub
resource[:name] must also stub resource.class.key_attributes
---
 spec/unit/provider/mount/parsed_spec.rb              | 1 +
 spec/unit/provider/ssh_authorized_key/parsed_spec.rb | 1 +
 2 files changed, 2 insertions(+)

(limited to 'spec')

diff --git a/spec/unit/provider/mount/parsed_spec.rb b/spec/unit/provider/mount/parsed_spec.rb
index 7d2e8a84c..3d37fc72e 100755
--- a/spec/unit/provider/mount/parsed_spec.rb
+++ b/spec/unit/provider/mount/parsed_spec.rb
@@ -51,6 +51,7 @@ module ParsedMountTesting
     #hash[:provider] = @provider_class.name
 
     fakeresource = stub :type => :mount, :name => hash[:name]
+    fakeresource.class.stubs(:key_attributes).returns([:name])
     fakeresource.stubs(:[]).with(:name).returns(hash[:name])
     fakeresource.stubs(:should).with(:target).returns(nil)
 
diff --git a/spec/unit/provider/ssh_authorized_key/parsed_spec.rb b/spec/unit/provider/ssh_authorized_key/parsed_spec.rb
index 11e9233e0..2e5be165a 100755
--- a/spec/unit/provider/ssh_authorized_key/parsed_spec.rb
+++ b/spec/unit/provider/ssh_authorized_key/parsed_spec.rb
@@ -104,6 +104,7 @@ describe provider_class do
   before :each do
     @resource = stub("resource", :name => "foo")
     @resource.stubs(:[]).returns "foo"
+    @resource.class.stubs(:key_attributes).returns( [:name] )
 
     @provider = provider_class.new(@resource)
     provider_class.stubs(:filetype).returns(Puppet::Util::FileType::FileTypeRam)
-- 
cgit 


From b7530389788effce9705e34c75aab5aad1ad5ee6 Mon Sep 17 00:00:00 2001
From: Stefan Schulte <stefan.schulte@taunusstein.net>
Date: Sun, 23 Jan 2011 16:55:19 +0100
Subject: (#4914) Add specs for modified mount type

---
 spec/unit/type/mount_spec.rb | 292 +++++++++++++++++++++++++++----------------
 1 file changed, 182 insertions(+), 110 deletions(-)

(limited to 'spec')

diff --git a/spec/unit/type/mount_spec.rb b/spec/unit/type/mount_spec.rb
index ce82cb516..45a6b6f5c 100755
--- a/spec/unit/type/mount_spec.rb
+++ b/spec/unit/type/mount_spec.rb
@@ -11,10 +11,14 @@ describe Puppet::Type.type(:mount) do
     mount = Puppet::Type.type(:mount).new(:name => "yay")
     mount.should(:ensure).should be_nil
   end
+
+  it "should have :name as the only keyattribut" do
+    Puppet::Type.type(:mount).key_attributes.should == [:name]
+  end
 end
 
 describe Puppet::Type.type(:mount), "when validating attributes" do
-  [:name, :remounts].each do |param|
+  [:name, :remounts, :provider].each do |param|
     it "should have a #{param} parameter" do
       Puppet::Type.type(:mount).attrtype(param).should == :param
     end
@@ -38,9 +42,16 @@ describe Puppet::Type.type(:mount)::Ensure, "when validating values" do
     mount.should(:ensure).should == :defined
   end
 
+  it "should support :present as a value to :ensure" do
+    Puppet::Type.type(:mount).new(:name => "yay", :ensure => :present)
+  end
+
+  it "should support :defined as a value to :ensure" do
+    Puppet::Type.type(:mount).new(:name => "yay", :ensure => :defined)
+  end
+
   it "should support :unmounted as a value to :ensure" do
-    mount = Puppet::Type.type(:mount).new(:name => "yay", :ensure => :unmounted)
-    mount.should(:ensure).should == :unmounted
+    Puppet::Type.type(:mount).new(:name => "yay", :ensure => :unmounted)
   end
 
   it "should support :absent as a value to :ensure" do
@@ -74,134 +85,150 @@ describe Puppet::Type.type(:mount)::Ensure do
     end
   end
 
-  describe Puppet::Type.type(:mount)::Ensure, "when retrieving its current state" do
+  describe Puppet::Type.type(:mount)::Ensure, "when changing the host" do
 
-    it "should return the provider's value if it is :absent" do
-      @provider.expects(:ensure).returns(:absent)
-      @ensure.retrieve.should == :absent
-    end
+    def test_ensure_change(options)
+      @provider.stubs(:get).with(:ensure).returns options[:from]
+      @provider.stubs(:ensure).returns options[:from]
+      @provider.stubs(:mounted?).returns([:mounted,:ghost].include? options[:from])
+      @provider.expects(:create).times(options[:create] || 0)
+      @provider.expects(:destroy).times(options[:destroy] || 0)
+      @provider.expects(:mount).times(options[:mount] || 0)
+      @provider.expects(:unmount).times(options[:unmount] || 0)
+      @ensure.stubs(:syncothers)
+      @ensure.should = options[:to]
+      @ensure.sync
+   end
 
-    it "should return :mounted if the provider indicates it is mounted and the value is not :absent" do
-      @provider.expects(:ensure).returns(:present)
-      @provider.expects(:mounted?).returns(true)
-      @ensure.retrieve.should == :mounted
-    end
+   it "should create itself when changing from :ghost to :present" do
+     test_ensure_change(:from => :ghost, :to => :present, :create => 1)
+   end
 
-    it "should return :unmounted if the provider indicates it is not mounted and the value is not :absent" do
-      @provider.expects(:ensure).returns(:present)
-      @provider.expects(:mounted?).returns(false)
-      @ensure.retrieve.should == :unmounted
-    end
-  end
+   it "should create itself when changing from :absent to :present" do
+     test_ensure_change(:from => :absent, :to => :present, :create => 1)
+   end
 
-  describe Puppet::Type.type(:mount)::Ensure, "when changing the host" do
+   it "should create itself and unmount when changing from :ghost to :unmounted" do
+     test_ensure_change(:from => :ghost, :to => :unmounted, :create => 1, :unmount => 1)
+   end
 
-    it "should destroy itself if it should be absent" do
-      @provider.stubs(:mounted?).returns(false)
-      @provider.expects(:destroy)
-      @ensure.should = :absent
-      @ensure.sync
-    end
+   it "should unmount resource when changing from :mounted to :unmounted" do
+     test_ensure_change(:from => :mounted, :to => :unmounted, :unmount => 1)
+   end
 
-    it "should unmount itself before destroying if it is mounted and should be absent" do
-      @provider.expects(:mounted?).returns(true)
-      @provider.expects(:unmount)
-      @provider.expects(:destroy)
-      @ensure.should = :absent
-      @ensure.sync
-    end
+   it "should create itself when changing from :absent to :unmounted" do
+     test_ensure_change(:from => :absent, :to => :unmounted, :create => 1)
+   end
 
-    it "should create itself if it is absent and should be defined" do
-      @provider.stubs(:ensure).returns(:absent)
-      @provider.stubs(:mounted?).returns(true)
+   it "should unmount resource when changing from :ghost to :absent" do
+     test_ensure_change(:from => :ghost, :to => :absent, :unmount => 1)
+   end
 
-      @provider.stubs(:mounted?).returns(false)
-      @provider.expects(:create)
-      @ensure.should = :defined
-      @ensure.sync
-    end
+   it "should unmount and destroy itself when changing from :mounted to :absent" do
+     test_ensure_change(:from => :mounted, :to => :absent, :destroy => 1, :unmount => 1)
+   end
 
-    it "should not unmount itself if it is mounted and should be defined" do
-      @provider.stubs(:ensure).returns(:mounted)
-      @provider.stubs(:mounted?).returns(true)
+   it "should destroy itself when changing from :unmounted to :absent" do
+     test_ensure_change(:from => :unmounted, :to => :absent, :destroy => 1)
+   end
 
-      @provider.stubs(:create)
-      @provider.expects(:mount).never
-      @provider.expects(:unmount).never
-      @ensure.should = :defined
-      @ensure.sync
-    end
+   it "should create itself when changing from :ghost to :mounted" do
+     test_ensure_change(:from => :ghost, :to => :mounted, :create => 1)
+   end
 
-    it "should not mount itself if it is unmounted and should be defined" do
-      @provider.stubs(:ensure).returns(:unmounted)
-      @provider.stubs(:mounted?).returns(false)
+   it "should create itself and mount when changing from :absent to :mounted" do
+     test_ensure_change(:from => :absent, :to => :mounted, :create => 1, :mount => 1)
+   end
 
-      @ensure.stubs(:syncothers)
-      @provider.stubs(:create)
-      @provider.expects(:mount).never
-      @provider.expects(:unmount).never
-      @ensure.should = :present
-      @ensure.sync
-    end
+   it "should mount resource when changing from :unmounted to :mounted" do
+     test_ensure_change(:from => :unmounted, :to => :mounted, :mount => 1)
+   end
 
-    it "should unmount itself if it is mounted and should be unmounted" do
-      @provider.stubs(:ensure).returns(:present)
-      @provider.stubs(:mounted?).returns(true)
 
-      @ensure.stubs(:syncothers)
-      @provider.expects(:unmount)
-      @ensure.should = :unmounted
-      @ensure.sync
-    end
+   it "should be in sync if it is :absent and should be :absent" do
+     @ensure.should = :absent
+     @ensure.insync?(:absent).should == true
+   end
 
-    it "should create and mount itself if it does not exist and should be mounted" do
-      @provider.stubs(:ensure).returns(:absent)
-      @provider.stubs(:mounted?).returns(false)
-      @provider.expects(:create)
-      @ensure.stubs(:syncothers)
-      @provider.expects(:mount)
-      @ensure.should = :mounted
-      @ensure.sync
-    end
+   it "should be out of sync if it is :absent and should be :defined" do
+     @ensure.should = :defined
+     @ensure.insync?(:absent).should == false
+   end
 
-    it "should mount itself if it is present and should be mounted" do
-      @provider.stubs(:ensure).returns(:present)
-      @provider.stubs(:mounted?).returns(false)
-      @ensure.stubs(:syncothers)
-      @provider.expects(:mount)
-      @ensure.should = :mounted
-      @ensure.sync
-    end
+   it "should be out of sync if it is :absent and should be :mounted" do
+     @ensure.should = :mounted
+     @ensure.insync?(:absent).should == false
+   end
 
-    it "should create but not mount itself if it is absent and mounted and should be mounted" do
-      @provider.stubs(:ensure).returns(:absent)
-      @provider.stubs(:mounted?).returns(true)
-      @ensure.stubs(:syncothers)
-      @provider.expects(:create)
-      @ensure.should = :mounted
-      @ensure.sync
-    end
+   it "should be out of sync if it is :absent and should be :unmounted" do
+     @ensure.should = :unmounted
+     @ensure.insync?(:absent).should == false
+   end
 
-    it "should be insync if it is mounted and should be defined" do
-      @ensure.should = :defined
-      @ensure.insync?(:mounted).should == true
-    end
 
-    it "should be insync if it is unmounted and should be defined" do
-      @ensure.should = :defined
-      @ensure.insync?(:unmounted).should == true
-    end
+   it "should be out of sync if it is :mounted and should be :absent" do
+     @ensure.should = :absent
+     @ensure.insync?(:mounted).should == false
+   end
 
-    it "should be insync if it is mounted and should be present" do
-      @ensure.should = :present
-      @ensure.insync?(:mounted).should == true
-    end
+   it "should be in sync if it is :mounted and should be :defined" do
+     @ensure.should = :defined
+     @ensure.insync?(:mounted).should == true
+   end
 
-    it "should be insync if it is unmounted and should be present" do
-      @ensure.should = :present
-      @ensure.insync?(:unmounted).should == true
-    end
-  end
+   it "should be in sync if it is :mounted and should be :mounted" do
+     @ensure.should = :mounted
+     @ensure.insync?(:mounted).should == true
+   end
+
+   it "should be out in sync if it is :mounted and should be :unmounted" do
+     @ensure.should = :unmounted
+     @ensure.insync?(:mounted).should == false
+   end
+
+
+   it "should be out of sync if it is :unmounted and should be :absent" do
+     @ensure.should = :absent
+     @ensure.insync?(:unmounted).should == false
+   end
+
+   it "should be in sync if it is :unmounted and should be :defined" do
+     @ensure.should = :defined
+     @ensure.insync?(:unmounted).should == true
+   end
+
+   it "should be out of sync if it is :unmounted and should be :mounted" do
+     @ensure.should = :mounted
+     @ensure.insync?(:unmounted).should == false
+   end
+
+   it "should be in sync if it is :unmounted and should be :unmounted" do
+     @ensure.should = :unmounted
+     @ensure.insync?(:unmounted).should == true
+   end
+
+
+   it "should be out of sync if it is :ghost and should be :absent" do
+     @ensure.should = :absent
+     @ensure.insync?(:ghost).should == false
+   end
+
+   it "should be out of sync if it is :ghost and should be :defined" do
+     @ensure.should = :defined
+     @ensure.insync?(:ghost).should == false
+   end
+
+   it "should be out of sync if it is :ghost and should be :mounted" do
+     @ensure.should = :mounted
+     @ensure.insync?(:ghost).should == false
+   end
+
+   it "should be out of sync if it is :ghost and should be :unmounted" do
+     @ensure.should = :unmounted
+     @ensure.insync?(:ghost).should == false
+   end
+
+ end
 
   describe Puppet::Type.type(:mount), "when responding to events" do
 
@@ -258,4 +285,49 @@ describe Puppet::Type.type(:mount), "when modifying an existing mount entry" do
 
     @catalog.apply
   end
+
+  it "should flush changes before mounting" do
+    syncorder = sequence('syncorder')
+    @mount.provider.expects(:options).returns 'soft'
+    @mount.provider.expects(:ensure).returns :unmounted
+    @mount.provider.expects(:mounted?).returns false
+
+    @mount.provider.expects(:options=).in_sequence(syncorder).with 'hard'
+    @mount.expects(:flush).in_sequence(syncorder) # Have to write with no options
+    @mount.provider.expects(:mount).in_sequence(syncorder)
+    @mount.expects(:flush).in_sequence(syncorder) # Call flush again cause we changed everything
+
+    @mount[:ensure] = :mounted
+    @mount[:options] = 'hard'
+
+    @catalog.apply
+  end
+
+  it "should not flush before mounting if there are no other changes" do
+    syncorder = sequence('syncorder')
+    @mount.provider.expects(:ensure).returns :unmounted
+    @mount.provider.expects(:mounted?).returns false
+    @mount.provider.expects(:mount).in_sequence(syncorder)
+    @mount.expects(:flush).in_sequence(syncorder) # Call flush cause we changed everything
+
+    @mount[:ensure] = :mounted
+    @catalog.apply
+  end
+
+  it "should umount before flushing changes to disk" do
+    syncorder = sequence('syncorder')
+    @mount.provider.expects(:options).returns 'soft'
+    @mount.provider.expects(:ensure).returns :mounted
+
+    @mount.provider.expects(:unmount).in_sequence(syncorder)
+    @mount.provider.expects(:options=).in_sequence(syncorder).with 'hard'
+    @mount.expects(:flush).in_sequence(syncorder) # Call inside syncothers
+    @mount.expects(:flush).in_sequence(syncorder) # I guess transaction or anything calls flush again
+
+    @mount[:ensure] = :unmounted
+    @mount[:options] = 'hard'
+
+    @catalog.apply
+  end
+
 end
-- 
cgit 


From f534470221fb97f2d25700f01c3f8c43aef73c26 Mon Sep 17 00:00:00 2001
From: Stefan Schulte <stefan.schulte@taunusstein.net>
Date: Tue, 25 Jan 2011 20:45:54 +0100
Subject: (#4914) Add specs for modified mount provider

Change specs
- No need to call flush before mounting (explicitly),
  because the type and syncothers will to that for us
- Add tests regarding the prefetched mount status
---
 spec/unit/provider/mount_spec.rb | 59 +++++++++++++++++++++++++++++++---------
 1 file changed, 46 insertions(+), 13 deletions(-)

(limited to 'spec')

diff --git a/spec/unit/provider/mount_spec.rb b/spec/unit/provider/mount_spec.rb
index b034214ee..232c559f4 100755
--- a/spec/unit/provider/mount_spec.rb
+++ b/spec/unit/provider/mount_spec.rb
@@ -19,18 +19,13 @@ describe Puppet::Provider::Mount do
 
   describe Puppet::Provider::Mount, " when mounting" do
 
-    it "should use the 'mountcmd' method to mount" do
-      @mounter.stubs(:options).returns(nil)
-      @mounter.expects(:mountcmd)
-
-      @mounter.mount
+    before :each do
+      @mounter.stubs(:get).with(:ensure).returns(:mounted)
     end
 
-    it "should flush before mounting if a flush method exists" do
-      @mounter.meta_def(:flush) { }
-      @mounter.expects(:flush)
-      @mounter.stubs(:mountcmd)
+    it "should use the 'mountcmd' method to mount" do
       @mounter.stubs(:options).returns(nil)
+      @mounter.expects(:mountcmd)
 
       @mounter.mount
     end
@@ -48,6 +43,23 @@ describe Puppet::Provider::Mount do
 
       @mounter.mount
     end
+
+    it "should update the :ensure state to :mounted if it was :unmounted before" do
+      @mounter.expects(:mountcmd)
+      @mounter.stubs(:options).returns(nil)
+      @mounter.expects(:get).with(:ensure).returns(:unmounted)
+      @mounter.expects(:set).with(:ensure => :mounted)
+      @mounter.mount
+    end
+
+    it "should update the :ensure state to :ghost if it was :absent before" do
+      @mounter.expects(:mountcmd)
+      @mounter.stubs(:options).returns(nil)
+      @mounter.expects(:get).with(:ensure).returns(:absent)
+      @mounter.expects(:set).with(:ensure => :ghost)
+      @mounter.mount
+    end
+
   end
 
   describe Puppet::Provider::Mount, " when remounting" do
@@ -77,21 +89,42 @@ describe Puppet::Provider::Mount do
 
   describe Puppet::Provider::Mount, " when unmounting" do
 
+    before :each do
+      @mounter.stubs(:get).with(:ensure).returns(:unmounted)
+    end
+
     it "should call the :umount command with the resource name" do
       @mounter.expects(:umount).with(@name)
       @mounter.unmount
     end
+
+    it "should update the :ensure state to :absent if it was :ghost before" do
+      @mounter.expects(:umount).with(@name).returns true
+      @mounter.expects(:get).with(:ensure).returns(:ghost)
+      @mounter.expects(:set).with(:ensure => :absent)
+      @mounter.unmount
+    end
+
+    it "should update the :ensure state to :unmounted if it was :mounted before" do
+      @mounter.expects(:umount).with(@name).returns true
+      @mounter.expects(:get).with(:ensure).returns(:mounted)
+      @mounter.expects(:set).with(:ensure => :unmounted)
+      @mounter.unmount
+    end
+
   end
 
   describe Puppet::Provider::Mount, " when determining if it is mounted" do
 
-    it "should parse the results of running the mount command with no arguments" do
-      Facter.stubs(:value).returns("whatever")
-      @mounter.expects(:mountcmd).returns("")
-
+    it "should query the property_hash" do
+      @mounter.expects(:get).with(:ensure).returns(:mounted)
       @mounter.mounted?
     end
 
+  end
+
+  describe Puppet::Provider::Mount, " when prefetching resources" do
+
     it "should match ' on /private/var/automount<name>' if the operating system is Darwin" do
       Facter.stubs(:value).with("operatingsystem").returns("Darwin")
       @mounter.expects(:mountcmd).returns("/dev/whatever on /private/var/automount/\ndevfs on /dev")
-- 
cgit 


From d6e4ffeb069686050b0ad1db544389be40e39b57 Mon Sep 17 00:00:00 2001
From: Stefan Schulte <stefan.schulte@taunusstein.net>
Date: Sun, 30 Jan 2011 20:34:27 +0100
Subject: (#4914) Specs for mounted? match new behaviour

The question if a filesystem is mounted or not can be answered without
calling mount and the specs have to reflect that.
---
 spec/unit/provider/mount_spec.rb | 50 +++++++++++-----------------------------
 1 file changed, 13 insertions(+), 37 deletions(-)

(limited to 'spec')

diff --git a/spec/unit/provider/mount_spec.rb b/spec/unit/provider/mount_spec.rb
index 232c559f4..3fc8a8664 100755
--- a/spec/unit/provider/mount_spec.rb
+++ b/spec/unit/provider/mount_spec.rb
@@ -121,50 +121,26 @@ describe Puppet::Provider::Mount do
       @mounter.mounted?
     end
 
-  end
-
-  describe Puppet::Provider::Mount, " when prefetching resources" do
-
-    it "should match ' on /private/var/automount<name>' if the operating system is Darwin" do
-      Facter.stubs(:value).with("operatingsystem").returns("Darwin")
-      @mounter.expects(:mountcmd).returns("/dev/whatever on /private/var/automount/\ndevfs on /dev")
-
-      @mounter.should be_mounted
+    it "should return true if prefetched value is :mounted" do
+      @mounter.stubs(:get).with(:ensure).returns(:mounted)
+      @mounter.mounted? == true
     end
 
-    it "should match ' on <name>' if the operating system is Darwin" do
-      Facter.stubs(:value).with("operatingsystem").returns("Darwin")
-      @mounter.expects(:mountcmd).returns("/dev/disk03 on / (local, journaled)\ndevfs on /dev")
-
-      @mounter.should be_mounted
+    it "should return true if prefetched value is :ghost" do
+      @mounter.stubs(:get).with(:ensure).returns(:ghost)
+      @mounter.mounted? == true
     end
 
-    it "should match '^<name> on' if the operating system is Solaris" do
-      Facter.stubs(:value).with("operatingsystem").returns("Solaris")
-      @mounter.expects(:mountcmd).returns("/ on /dev/dsk/whatever\n/var on /dev/dsk/other")
-
-      @mounter.should be_mounted
+    it "should return false if prefetched value is :absent" do
+      @mounter.stubs(:get).with(:ensure).returns(:absent)
+      @mounter.mounted? == false
     end
 
-    it "should match '^<name> on' if the operating system is HP-UX" do
-      Facter.stubs(:value).with("operatingsystem").returns("HP-UX")
-      @mounter.expects(:mountcmd).returns("/ on /dev/dsk/whatever\n/var on /dev/dsk/other")
-
-      @mounter.should be_mounted
-    end
-
-    it "should match ' on <name>' if the operating system is not Darwin, Solaris, or HP-UX" do
-      Facter.stubs(:value).with("operatingsystem").returns("Debian")
-      @mounter.expects(:mountcmd).returns("/dev/dsk/whatever on / and stuff\n/dev/other/disk on /var and stuff")
-
-      @mounter.should be_mounted
+    it "should return false if prefetched value is :unmounted" do
+      @mounter.stubs(:get).with(:ensure).returns(:unmounted)
+      @mounter.mounted? == false
     end
 
-    it "should not be considered mounted if it did not match the mount output" do
-      Facter.stubs(:value).with("operatingsystem").returns("Debian")
-      @mounter.expects(:mountcmd).returns("/dev/dsk/whatever on /something/else and stuff\n/dev/other/disk on /var and stuff")
-
-      @mounter.should_not be_mounted
-    end
   end
+
 end
-- 
cgit 


From 48bc7d00ca87fa92cdde0b993529bba3827fa47e Mon Sep 17 00:00:00 2001
From: Brice Figureau <brice-puppet@daysofwonder.com>
Date: Fri, 11 Feb 2011 20:18:14 +0100
Subject: Fix #6280 - puppetdoc crashing on string interpolation

The following manifest was crashing puppetdoc:
  class test {
     include "test::$operatingsystem"
  }

Because the quoted string is "rendered" as a concat AST, which in turn
ended being an array when entering RDoc.

Signed-off-by: Brice Figureau <brice-puppet@daysofwonder.com>
---
 spec/unit/util/rdoc/parser_spec.rb | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

(limited to 'spec')

diff --git a/spec/unit/util/rdoc/parser_spec.rb b/spec/unit/util/rdoc/parser_spec.rb
index 28c33c295..3295e9031 100755
--- a/spec/unit/util/rdoc/parser_spec.rb
+++ b/spec/unit/util/rdoc/parser_spec.rb
@@ -339,7 +339,7 @@ describe RDoc::Parser do
   describe "when scanning for includes and requires" do
 
     def create_stmt(name)
-      stmt_value = stub "#{name}_value", :value => "myclass"
+      stmt_value = stub "#{name}_value", :to_s => "myclass"
 
       Puppet::Parser::AST::Function.new(
         :name      => name,
@@ -357,13 +357,13 @@ describe RDoc::Parser do
     it "should also scan mono-instruction code" do
       @class.expects(:add_include).with { |i| i.is_a?(RDoc::Include) and i.name == "myclass" and i.comment == "mydoc" }
 
-      @parser.scan_for_include_or_require(@class,create_stmt("include"))
+      @parser.scan_for_include_or_require(@class, create_stmt("include"))
     end
 
     it "should register recursively includes to the current container" do
       @code.stubs(:children).returns([ create_stmt("include") ])
 
-      @class.expects(:add_include).with { |i| i.is_a?(RDoc::Include) and i.name == "myclass" and i.comment == "mydoc" }
+      @class.expects(:add_include)#.with { |i| i.is_a?(RDoc::Include) and i.name == "myclass" and i.comment == "mydoc" }
       @parser.scan_for_include_or_require(@class, [@code])
     end
 
-- 
cgit 


From cfa0c32fc5149464af97235a7bb458950d19cc82 Mon Sep 17 00:00:00 2001
From: Brice Figureau <brice-puppet@daysofwonder.com>
Date: Fri, 11 Feb 2011 20:34:22 +0100
Subject: Fix #6281 - Make sure puppetdoc analyzes all files

It can happen that when parsing a file puppet parses other manifests
if they get imported (this is at least true for site.pp, even in
ignoreimport=true). Thus those files are now "watched".
But puppetdoc needs to analyze all files, and since 99c101 we are now
checking if the file was already parsed to not reparse it again.
If that was the case, though, we weren't analyzing the produced code.
Thus it was possible to not produce documentation for the site.pp content.

Signed-off-by: Brice Figureau <brice-puppet@daysofwonder.com>
---
 spec/unit/util/rdoc/parser_spec.rb | 12 ++++++++++++
 1 file changed, 12 insertions(+)

(limited to 'spec')

diff --git a/spec/unit/util/rdoc/parser_spec.rb b/spec/unit/util/rdoc/parser_spec.rb
index 3295e9031..b4453ae86 100755
--- a/spec/unit/util/rdoc/parser_spec.rb
+++ b/spec/unit/util/rdoc/parser_spec.rb
@@ -43,6 +43,18 @@ describe RDoc::Parser do
 
       @parser.scan.should be_a(RDoc::PuppetTopLevel)
     end
+
+    it "should scan the top level even if the file has already parsed" do
+      known_type = stub 'known_types'
+      env = stub 'env'
+      Puppet::Node::Environment.stubs(:new).returns(env)
+      env.stubs(:known_resource_types).returns(known_type)
+      known_type.expects(:watching_file?).with("module/manifests/init.pp").returns(true)
+
+      @parser.expects(:scan_top_level)
+
+      @parser.scan
+    end
   end
 
   describe "when scanning top level entities" do
-- 
cgit 


From b4a171e78c501208798220910352943331ceb9e0 Mon Sep 17 00:00:00 2001
From: Brice Figureau <brice-puppet@daysofwonder.com>
Date: Fri, 11 Feb 2011 22:46:15 +0100
Subject: Fix #5720 - puppetdoc misses some class comments

It appears that the fix for #5252 wasn't complete, and class, nodes and
definition were still using the current lexer line number instead of
the line number of the class/define/node token.
This combined with some missing comments stack pushing/pop on parenthesis
prevented puppetdoc to correctly get the documentation of some class (including
parametrized ones).

Signed-off-by: Brice Figureau <brice-puppet@daysofwonder.com>
---
 spec/unit/parser/lexer_spec.rb  | 16 ++++++++++++++++
 spec/unit/parser/parser_spec.rb | 27 +++++++++++++++++++++++++++
 2 files changed, 43 insertions(+)

(limited to 'spec')

diff --git a/spec/unit/parser/lexer_spec.rb b/spec/unit/parser/lexer_spec.rb
index 860326973..4ef242cf5 100755
--- a/spec/unit/parser/lexer_spec.rb
+++ b/spec/unit/parser/lexer_spec.rb
@@ -529,6 +529,22 @@ describe Puppet::Parser::Lexer, "when lexing comments" do
     @lexer.fullscan
   end
 
+  it "should add a new comment stack level on LPAREN" do
+    @lexer.string = "("
+
+    @lexer.expects(:commentpush)
+
+    @lexer.fullscan
+  end
+
+  it "should pop the current comment on RPAREN" do
+    @lexer.string = ")"
+
+    @lexer.expects(:commentpop)
+
+    @lexer.fullscan
+  end
+
   it "should return the current comments on getcomment" do
     @lexer.string = "# comment"
     @lexer.fullscan
diff --git a/spec/unit/parser/parser_spec.rb b/spec/unit/parser/parser_spec.rb
index 07e2d220b..9aab6a716 100755
--- a/spec/unit/parser/parser_spec.rb
+++ b/spec/unit/parser/parser_spec.rb
@@ -304,6 +304,33 @@ describe Puppet::Parser do
     it "should return an array of nodes" do
       @parser.newnode(@nodename).should be_instance_of(Array)
     end
+
+    it "should initialize the ast context with the correct line number" do
+      @parser.expects(:ast_context).with { |a,b| b == 123 }.returns({})
+      @parser.newnode(@nodename, { :line => 123 })
+    end
+  end
+
+  %w{class define}.each do |entity|
+    describe "when creating a #{entity}" do
+      before :each do
+        @parser.stubs(:ast_context).returns({})
+
+        @name = stub "#{entity}name", :is_a? => false, :value => "foo"
+      end
+
+      it "should create and add the correct resource type" do
+        instance = stub 'instance'
+        Puppet::Resource::Type.expects(:new).returns(instance)
+        @parser.known_resource_types.expects(:add).with(instance)
+        @parser.send("new#{entity}", @name)
+      end
+
+      it "should initialize the ast context with the correct line number" do
+        @parser.expects(:ast_context).with { |a,b| b == 123 }.returns({})
+        @parser.send("new#{entity}", @name, { :line => 123 })
+      end
+    end
   end
 
   describe "when retrieving a specific node" do
-- 
cgit 


From c373b6272ddd4daabf15d1b459ef3e86072e3f26 Mon Sep 17 00:00:00 2001
From: Brice Figureau <brice-puppet@daysofwonder.com>
Date: Sat, 12 Feb 2011 16:58:20 +0100
Subject: Fix #6269 - Hashes only work with two levels of access

The following manifest was failing:
  $hash = { 'a' => { 'b' => { 'c' => 'it works' } } }
  $out = $hash['a']['b']['c']

because of a typo in the grammar.

Signed-off-by: Brice Figureau <brice-puppet@daysofwonder.com>
---
 spec/integration/parser/parser_spec.rb | 7 +++++++
 1 file changed, 7 insertions(+)

(limited to 'spec')

diff --git a/spec/integration/parser/parser_spec.rb b/spec/integration/parser/parser_spec.rb
index 7b85bcacb..20d87c228 100755
--- a/spec/integration/parser/parser_spec.rb
+++ b/spec/integration/parser/parser_spec.rb
@@ -109,5 +109,12 @@ describe Puppet::Parser::Parser do
     it "should correctly set the arrow type of a relationship" do
       "Notify[foo] <~ Notify[bar]".should parse_with { |rel| rel.arrow == "<~" }
     end
+
+    it "should be able to parse deep hash access" do
+      %q{
+        $hash = { 'a' => { 'b' => { 'c' => 'it works' } } }
+        $out = $hash['a']['b']['c']
+      }.should parse_with { |v| v.value.is_a?(Puppet::Parser::AST::ASTHash) }
+    end
   end
 end
-- 
cgit 


From 414e3a5989c4c1010af0c5d3f61af2608d91d9b8 Mon Sep 17 00:00:00 2001
From: Brice Figureau <brice-puppet@daysofwonder.com>
Date: Sat, 12 Feb 2011 17:34:35 +0100
Subject: Fix #5516 - Hashes can't be used in selectors

The following manifest was producing a parse error:
$int = { 'eth0' => 'bla' }
$foo = $int['eth0'] ? {
  'bla' => 'foo',
   default => 'bleh'
}

because selectors didn't support hash access.

Signed-off-by: Brice Figureau <brice-puppet@daysofwonder.com>
---
 spec/unit/parser/parser_spec.rb | 6 ++++++
 1 file changed, 6 insertions(+)

(limited to 'spec')

diff --git a/spec/unit/parser/parser_spec.rb b/spec/unit/parser/parser_spec.rb
index 07e2d220b..9e4c79588 100755
--- a/spec/unit/parser/parser_spec.rb
+++ b/spec/unit/parser/parser_spec.rb
@@ -76,6 +76,12 @@ describe Puppet::Parser do
 
   end
 
+  describe "when parsing selector" do
+    it "should support hash access on the left hand side" do
+      lambda { @parser.parse("$h = { 'a' => 'b' } $a = $h['a'] ? { 'b' => 'd', default => undef }") }.should_not raise_error
+    end
+  end
+
   describe "when parsing 'if'" do
     it "not, it should create the correct ast objects" do
       ast::Not.expects(:new).with { |h| h[:value].is_a?(ast::Boolean) }
-- 
cgit 


From b5b5923bf41196f5e72a69bfa627120c75732fe5 Mon Sep 17 00:00:00 2001
From: Daniel Pittman <daniel@rimspace.net>
Date: Sat, 12 Feb 2011 11:44:19 -0800
Subject: misc: ast_context has two arguments, not one.

This updates the spec expectation to reflect that, eliminating a warning
during the spec run.
---
 spec/unit/parser/parser_spec.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'spec')

diff --git a/spec/unit/parser/parser_spec.rb b/spec/unit/parser/parser_spec.rb
index 9aab6a716..2f5d4b8ea 100755
--- a/spec/unit/parser/parser_spec.rb
+++ b/spec/unit/parser/parser_spec.rb
@@ -276,7 +276,7 @@ describe Puppet::Parser do
     it "should include docs when the AST class uses them" do
       @class.expects(:use_docs).returns true
       @class.stubs(:new)
-      @parser.expects(:ast_context).with{ |a| a[0] == true }.returns({})
+      @parser.expects(:ast_context).with{ |docs, line| docs == true }.returns({})
       @parser.ast(@class, :file => "/bar")
     end
 
-- 
cgit 


From e512e3effa134271564177e095c6afc19bebe62f Mon Sep 17 00:00:00 2001
From: Daniel Pittman <daniel@rimspace.net>
Date: Sat, 12 Feb 2011 12:09:27 -0800
Subject: (#5977) fix spec test failure when new applications are introduced.

The test here was previously fragile, in that it would break when new
applications were introduced, and in that it depended on the order of items
returned from reading the directories on disk.

It is now insensitive to those changes, and still verifies that the results we
require occur, reducing long term maintenance cost.

Reviewed-by: James Turnbull <james@puppetlabs.com>
---
 spec/unit/util/command_line_spec.rb | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)
 mode change 100644 => 100755 spec/unit/util/command_line_spec.rb

(limited to 'spec')

diff --git a/spec/unit/util/command_line_spec.rb b/spec/unit/util/command_line_spec.rb
old mode 100644
new mode 100755
index a648eb4a1..98ddb92f6
--- a/spec/unit/util/command_line_spec.rb
+++ b/spec/unit/util/command_line_spec.rb
@@ -108,8 +108,8 @@ describe Puppet::Util::CommandLine do
   end
   describe 'when loading commands' do
     before do
-      @core_apps = ["describe", "filebucket", "kick", "queue", "resource", "agent", "cert", "apply", "doc", "master"]
-      @command_line = Puppet::Util::CommandLine.new("foo", %w{ client --help w    hatever.pp }, @tty )
+      @core_apps = %w{describe filebucket kick queue resource agent cert apply doc master}
+      @command_line = Puppet::Util::CommandLine.new("foo", %w{ client --help whatever.pp }, @tty )
     end
     it 'should be able to find all existing commands' do
       @core_apps.each do |command|
@@ -122,10 +122,15 @@ describe Puppet::Util::CommandLine do
         @appdir="#{@dir}/puppet/application"
         FileUtils.mkdir_p(@appdir)
         FileUtils.touch("#{@appdir}/foo.rb")
-        $LOAD_PATH.unshift(@dir)
+        $LOAD_PATH.unshift(@dir) # WARNING: MUST MATCH THE AFTER ACTIONS!
       end
       it 'should be able to find commands from both paths' do
-        @command_line.available_subcommands.should == ['foo'] + @core_apps
+        found = @command_line.available_subcommands
+        found.should include 'foo'
+        @core_apps.each { |cmd| found.should include cmd }
+      end
+      after do
+        $LOAD_PATH.shift        # WARNING: MUST MATCH THE BEFORE ACTIONS!
       end
     end
   end
-- 
cgit 


From 7cb884e44db412ed4cc19d9eb3e07d4b5b17f6b3 Mon Sep 17 00:00:00 2001
From: Matt Robinson <matt@puppetlabs.com>
Date: Tue, 15 Feb 2011 17:10:42 -0800
Subject: (#6346) Move the trap calls onto Signal so they're easier to stub

Once you stub signal traps in tests, you can hit ctrl+c in the middle of
a spec run and it will stop the run instead of puppet catching the
SIGINT.

I had trouble easily tracking down all the places to stub traps when the
trap was being called as a private method on applications and daemons,
but calling trap on Signal is equivalent since Kernel calls Signal.trap
and Object mixes in Kernel to provide trap as a private method on all
objects.

A bigger solution would be to refactor everywhere we call trap into a
method that's called consistently since right now we sprinkle SIGINT and
SIGTERM trap handling over applications and daemons in inconsistent
ways, returning different error codes and using different messages.
I've captured this info in ticket #6345.

Reviewed-by: Jacob Helwig <jacob@puppetlabs.com>
---
 spec/spec_helper.rb                      | 1 +
 spec/unit/application/agent_spec.rb      | 6 +-----
 spec/unit/application/apply_spec.rb      | 3 +--
 spec/unit/application/filebucket_spec.rb | 2 +-
 spec/unit/application/queue_spec.rb      | 6 +-----
 spec/unit/daemon_spec.rb                 | 6 +-----
 6 files changed, 6 insertions(+), 18 deletions(-)

(limited to 'spec')

diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index ed4e826c9..a374fb008 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -64,6 +64,7 @@ RSpec.configure do |config|
     # these globals are set by Application
     $puppet_application_mode = nil
     $puppet_application_name = nil
+    Signal.stubs(:trap)
 
     # Set the confdir and vardir to gibberish so that tests
     # have to be correctly mocked.
diff --git a/spec/unit/application/agent_spec.rb b/spec/unit/application/agent_spec.rb
index ff504eedf..9fc7879c9 100755
--- a/spec/unit/application/agent_spec.rb
+++ b/spec/unit/application/agent_spec.rb
@@ -50,12 +50,8 @@ describe Puppet::Application::Agent do
   end
 
   describe "in preinit" do
-    before :each do
-      @puppetd.stubs(:trap)
-    end
-
     it "should catch INT" do
-      @puppetd.expects(:trap).with { |arg,block| arg == :INT }
+      Signal.expects(:trap).with { |arg,block| arg == :INT }
 
       @puppetd.preinit
     end
diff --git a/spec/unit/application/apply_spec.rb b/spec/unit/application/apply_spec.rb
index 4e1744206..ceba4a333 100755
--- a/spec/unit/application/apply_spec.rb
+++ b/spec/unit/application/apply_spec.rb
@@ -52,7 +52,6 @@ describe Puppet::Application::Apply do
 
     before :each do
       Puppet::Log.stubs(:newdestination)
-      Puppet.stubs(:trap)
       Puppet::Log.stubs(:level=)
       Puppet.stubs(:parse_config)
       Puppet::FileBucket::Dipper.stubs(:new)
@@ -78,7 +77,7 @@ describe Puppet::Application::Apply do
     end
 
     it "should set INT trap" do
-      @apply.expects(:trap).with(:INT)
+      Signal.expects(:trap).with(:INT)
 
       @apply.setup
     end
diff --git a/spec/unit/application/filebucket_spec.rb b/spec/unit/application/filebucket_spec.rb
index e6272f179..95135c7eb 100644
--- a/spec/unit/application/filebucket_spec.rb
+++ b/spec/unit/application/filebucket_spec.rb
@@ -56,7 +56,7 @@ describe Puppet::Application::Filebucket do
     end
 
     it "should trap INT" do
-      @filebucket.expects(:trap).with(:INT)
+      Signal.expects(:trap).with(:INT)
 
       @filebucket.setup
     end
diff --git a/spec/unit/application/queue_spec.rb b/spec/unit/application/queue_spec.rb
index bd0d53ab1..f8ebbd0b4 100755
--- a/spec/unit/application/queue_spec.rb
+++ b/spec/unit/application/queue_spec.rb
@@ -29,12 +29,8 @@ describe Puppet::Application::Queue do
   end
 
   describe "in preinit" do
-    before :each do
-      @queue.stubs(:trap)
-    end
-
     it "should catch INT" do
-      @queue.expects(:trap).with { |arg,block| arg == :INT }
+      Signal.expects(:trap).with { |arg,block| arg == :INT }
 
       @queue.preinit
     end
diff --git a/spec/unit/daemon_spec.rb b/spec/unit/daemon_spec.rb
index e24db7881..39592b7c9 100755
--- a/spec/unit/daemon_spec.rb
+++ b/spec/unit/daemon_spec.rb
@@ -29,13 +29,9 @@ describe Puppet::Daemon do
   end
 
   describe "when setting signal traps" do
-    before do
-      @daemon.stubs(:trap)
-    end
-
     {:INT => :stop, :TERM => :stop, :HUP => :restart, :USR1 => :reload, :USR2 => :reopen_logs}.each do |signal, method|
       it "should log and call #{method} when it receives #{signal}" do
-        @daemon.expects(:trap).with(signal).yields
+        Signal.expects(:trap).with(signal).yields
 
         Puppet.expects(:notice)
 
-- 
cgit 


From e3c59df2b246fe5e764272f21b631a5d2f28687f Mon Sep 17 00:00:00 2001
From: Nick Lewis <nick@puppetlabs.com>
Date: Thu, 17 Feb 2011 13:52:40 -0800
Subject: (#5935) Allow functions to accept negated values

function(-1) was failing because the grammar wasn't allowing negated values in
function calls. This fix makes the negation of any value which was previously
legal as a function argument also now legal as a function argument.

Paired-With: Max Martin
Paired-With: Markus Roberts
---
 spec/integration/parser/parser_spec.rb | 13 +++++++++++++
 1 file changed, 13 insertions(+)

(limited to 'spec')

diff --git a/spec/integration/parser/parser_spec.rb b/spec/integration/parser/parser_spec.rb
index 20d87c228..000e68dd8 100755
--- a/spec/integration/parser/parser_spec.rb
+++ b/spec/integration/parser/parser_spec.rb
@@ -116,5 +116,18 @@ describe Puppet::Parser::Parser do
         $out = $hash['a']['b']['c']
       }.should parse_with { |v| v.value.is_a?(Puppet::Parser::AST::ASTHash) }
     end
+
+    it "should be able to pass numbers to functions" do
+      %q{
+        my_function(1)
+      }.should parse_as(Puppet::Parser::AST::Function)
+    end
+
+    it "should be able to pass negative numbers to functions" do
+      %q{
+        my_function(-1)
+      }.should parse_as(Puppet::Parser::AST::Function)
+    end
+
   end
 end
-- 
cgit 


From 23fc4db954c22bce2c6cc8996d5fafb175e2b747 Mon Sep 17 00:00:00 2001
From: Paul Berry <paul@puppetlabs.com>
Date: Thu, 17 Feb 2011 14:59:59 -0800
Subject: (#5132) Provide a query REST interface for inventory

This REST interface returns a list of nodes that match a fact query.
Fact queries can use (in)equality testing as a string comparison, and >,
<, >=, <= numerical comparisons.  Multiple tests can be done as AND
comparisons, not OR.

The fact queries need to be prefixed by facts, and the comparisons other
than equality are specified with a .comparison_type after the fact name.

This will be better explained in the REST documentation on the website.

Searches that don't match anything now return empty array instead of a
404 error.

Conflicts:

	spec/spec_helper.rb
---
 spec/unit/indirector/facts/yaml_spec.rb     |   4 +-
 spec/unit/indirector/inventory/yaml_spec.rb | 130 ++++++++++++++++++++++++++++
 spec/unit/network/http/api/v1_spec.rb       |  12 +++
 spec/unit/network/http/handler_spec.rb      |  11 ++-
 4 files changed, 151 insertions(+), 6 deletions(-)
 create mode 100644 spec/unit/indirector/inventory/yaml_spec.rb

(limited to 'spec')

diff --git a/spec/unit/indirector/facts/yaml_spec.rb b/spec/unit/indirector/facts/yaml_spec.rb
index e7bac3471..37a1bcae0 100755
--- a/spec/unit/indirector/facts/yaml_spec.rb
+++ b/spec/unit/indirector/facts/yaml_spec.rb
@@ -10,9 +10,9 @@ describe Puppet::Node::Facts::Yaml do
     Puppet::Node::Facts::Yaml.superclass.should equal(Puppet::Indirector::Yaml)
   end
 
-
   it "should have documentation" do
     Puppet::Node::Facts::Yaml.doc.should_not be_nil
+    Puppet::Node::Facts::Yaml.doc.should_not be_empty
   end
 
   it "should be registered with the facts indirection" do
@@ -20,7 +20,7 @@ describe Puppet::Node::Facts::Yaml do
     Puppet::Node::Facts::Yaml.indirection.should equal(indirection)
   end
 
-  it "should have its name set to :facts" do
+  it "should have its name set to :yaml" do
     Puppet::Node::Facts::Yaml.name.should == :yaml
   end
 end
diff --git a/spec/unit/indirector/inventory/yaml_spec.rb b/spec/unit/indirector/inventory/yaml_spec.rb
new file mode 100644
index 000000000..3a7035a9e
--- /dev/null
+++ b/spec/unit/indirector/inventory/yaml_spec.rb
@@ -0,0 +1,130 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet/node/inventory'
+require 'puppet/indirector/inventory/yaml'
+require 'puppet/indirector/request'
+
+describe Puppet::Node::Inventory::Yaml do
+  def setup_search_matching(matching, nonmatching, query)
+    request = Puppet::Indirector::Request.new(:inventory, :search, nil, query)
+
+    Dir.stubs(:glob).returns(matching.keys + nonmatching.keys)
+    [matching, nonmatching].each do |examples|
+      examples.each do |key, value|
+        YAML.stubs(:load_file).with(key).returns value
+      end
+    end
+    return matching, request
+  end
+
+  it "should return node names that match the search query options" do
+    matching, request = setup_search_matching({
+        '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386", 'processor_count' => '4'),
+        '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "i386", 'processor_count' => '4', 'randomfact' => 'foo')
+      },
+      {
+        "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '4'),
+        "/path/to/nonmatching1.yaml" => Puppet::Node::Facts.new("nonmatchingnode1", "architecture" => "powerpc", 'processor_count' => '5'),
+        "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '5'),
+        "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3",                              'processor_count' => '4'),
+      },
+      {'facts.architecture' => 'i386', 'facts.processor_count' => '4'}
+    )
+    Puppet::Node::Inventory::Yaml.new.search(request).should =~ matching.values.map {|facts| facts.name}
+  end
+
+  it "should return empty array when no nodes match the search query options" do
+    matching, request = setup_search_matching({}, {
+        "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '10'),
+        "/path/to/nonmatching1.yaml" => Puppet::Node::Facts.new("nonmatchingnode1", "architecture" => "powerpc", 'processor_count' => '5'),
+        "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '5'),
+        "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3",                              'processor_count' => '4'),
+      },
+      {'facts.processor_count.lt' => '4', 'facts.processor_count.gt' => '4'}
+    )
+    Puppet::Node::Inventory::Yaml.new.search(request).should =~ matching.values.map {|facts| facts.name}
+  end
+
+
+  it "should return node names that match the search query options with the greater than operator" do
+    matching, request = setup_search_matching({
+        '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '5'),
+        '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '10', 'randomfact' => 'foo')
+      },
+      {
+        "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '4'),
+        "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '3'),
+        "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                       ),
+      },
+      {'facts.processor_count.gt' => '4'}
+    )
+
+    Puppet::Node::Inventory::Yaml.new.search(request).should =~ matching.values.map {|facts| facts.name}
+  end
+
+  it "should return node names that match the search query options with the less than operator" do
+    matching, request = setup_search_matching({
+        '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '5'),
+        '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '30', 'randomfact' => 'foo')
+      },
+      {
+        "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '50' ),
+        "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '100'),
+        "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                         ),
+      },
+      {'facts.processor_count.lt' => '50'}
+    )
+
+    Puppet::Node::Inventory::Yaml.new.search(request).should =~ matching.values.map {|facts| facts.name}
+  end
+
+  it "should return node names that match the search query options with the less than or equal to operator" do
+    matching, request = setup_search_matching({
+        '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '5'),
+        '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '50', 'randomfact' => 'foo')
+      },
+      {
+        "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '100' ),
+        "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '5000'),
+        "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                          ),
+      },
+      {'facts.processor_count.le' => '50'}
+    )
+
+    Puppet::Node::Inventory::Yaml.new.search(request).should =~ matching.values.map {|facts| facts.name}
+  end
+
+  it "should return node names that match the search query options with the greater than or equal to operator" do
+    matching, request = setup_search_matching({
+        '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '100'),
+        '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '50', 'randomfact' => 'foo')
+      },
+      {
+        "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '40'),
+        "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '9' ),
+        "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                        ),
+      },
+      {'facts.processor_count.ge' => '50'}
+    )
+
+    Puppet::Node::Inventory::Yaml.new.search(request).should =~ matching.values.map {|facts| facts.name}
+  end
+
+  it "should return node names that match the search query options with the not equal operator" do
+    matching, request = setup_search_matching({
+        '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => 'arm'                           ),
+        '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => 'powerpc', 'randomfact' => 'foo')
+      },
+      {
+        "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "i386"                           ),
+        "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386", 'processor_count' => '9' ),
+        "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                     ),
+      },
+      {'facts.architecture.ne' => 'i386'}
+    )
+
+    Puppet::Node::Inventory::Yaml.new.search(request).should =~ matching.values.map {|facts| facts.name}
+  end
+end
diff --git a/spec/unit/network/http/api/v1_spec.rb b/spec/unit/network/http/api/v1_spec.rb
index 23a291cf3..d47fc8d81 100644
--- a/spec/unit/network/http/api/v1_spec.rb
+++ b/spec/unit/network/http/api/v1_spec.rb
@@ -76,6 +76,18 @@ describe Puppet::Network::HTTP::API::V1 do
       @tester.uri2indirection("GET", "/env/foos/bar", {}).method.should == :search
     end
 
+    it "should choose 'find' as the indirection method if the http method is a GET and the indirection name is facts" do
+      @tester.uri2indirection("GET", "/env/facts/bar", {}).method.should == :find
+    end
+
+    it "should choose 'save' as the indirection method if the http method is a PUT and the indirection name is facts" do
+      @tester.uri2indirection("PUT", "/env/facts/bar", {}).method.should == :save
+    end
+
+    it "should choose 'search' as the indirection method if the http method is a GET and the indirection name is inventory" do
+      @tester.uri2indirection("GET", "/env/inventory/search", {}).method.should == :search
+    end
+
     it "should choose 'delete' as the indirection method if the http method is a DELETE and the indirection name is singular" do
       @tester.uri2indirection("DELETE", "/env/foo/bar", {}).method.should == :destroy
     end
diff --git a/spec/unit/network/http/handler_spec.rb b/spec/unit/network/http/handler_spec.rb
index 8464ae68e..68c7b9aa3 100755
--- a/spec/unit/network/http/handler_spec.rb
+++ b/spec/unit/network/http/handler_spec.rb
@@ -344,17 +344,20 @@ describe Puppet::Network::HTTP::Handler do
         @handler.do_search(@irequest, @request, @response)
       end
 
-      it "should return a 404 when searching returns an empty array" do
-        @model_class.stubs(:name).returns "my name"
-        @handler.expects(:set_response).with { |response, body, status| status == 404 }
+      it "should return [] when searching returns an empty array" do
+        @handler.expects(:accept_header).with(@request).returns "one,two"
         @model_class.stubs(:search).returns([])
+        @model_class.expects(:render_multiple).with(@oneformat, []).returns "[]"
+
+
+        @handler.expects(:set_response).with { |response, data| data == "[]" }
         @handler.do_search(@irequest, @request, @response)
       end
 
       it "should return a 404 when searching returns nil" do
         @model_class.stubs(:name).returns "my name"
         @handler.expects(:set_response).with { |response, body, status| status == 404 }
-        @model_class.stubs(:search).returns([])
+        @model_class.stubs(:search).returns(nil)
         @handler.do_search(@irequest, @request, @response)
       end
     end
-- 
cgit 


From fa0ed63c321819159f54621d7799ebc1eb2102f7 Mon Sep 17 00:00:00 2001
From: Paul Berry <paul@puppetlabs.com>
Date: Mon, 1 Nov 2010 13:32:14 -0700
Subject: Refactored Puppet::Node::Inventory::Yaml tests in preparation for
 adding freshness check

---
 spec/unit/indirector/inventory/yaml_spec.rb | 30 +++++++++--------------------
 1 file changed, 9 insertions(+), 21 deletions(-)

(limited to 'spec')

diff --git a/spec/unit/indirector/inventory/yaml_spec.rb b/spec/unit/indirector/inventory/yaml_spec.rb
index 3a7035a9e..a595f8a43 100644
--- a/spec/unit/indirector/inventory/yaml_spec.rb
+++ b/spec/unit/indirector/inventory/yaml_spec.rb
@@ -7,7 +7,7 @@ require 'puppet/indirector/inventory/yaml'
 require 'puppet/indirector/request'
 
 describe Puppet::Node::Inventory::Yaml do
-  def setup_search_matching(matching, nonmatching, query)
+  def assert_search_matches(matching, nonmatching, query)
     request = Puppet::Indirector::Request.new(:inventory, :search, nil, query)
 
     Dir.stubs(:glob).returns(matching.keys + nonmatching.keys)
@@ -16,11 +16,11 @@ describe Puppet::Node::Inventory::Yaml do
         YAML.stubs(:load_file).with(key).returns value
       end
     end
-    return matching, request
+    Puppet::Node::Inventory::Yaml.new.search(request).should =~ matching.values.map {|facts| facts.name}
   end
 
   it "should return node names that match the search query options" do
-    matching, request = setup_search_matching({
+    assert_search_matches({
         '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386", 'processor_count' => '4'),
         '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "i386", 'processor_count' => '4', 'randomfact' => 'foo')
       },
@@ -32,11 +32,10 @@ describe Puppet::Node::Inventory::Yaml do
       },
       {'facts.architecture' => 'i386', 'facts.processor_count' => '4'}
     )
-    Puppet::Node::Inventory::Yaml.new.search(request).should =~ matching.values.map {|facts| facts.name}
   end
 
   it "should return empty array when no nodes match the search query options" do
-    matching, request = setup_search_matching({}, {
+    assert_search_matches({}, {
         "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '10'),
         "/path/to/nonmatching1.yaml" => Puppet::Node::Facts.new("nonmatchingnode1", "architecture" => "powerpc", 'processor_count' => '5'),
         "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '5'),
@@ -44,12 +43,11 @@ describe Puppet::Node::Inventory::Yaml do
       },
       {'facts.processor_count.lt' => '4', 'facts.processor_count.gt' => '4'}
     )
-    Puppet::Node::Inventory::Yaml.new.search(request).should =~ matching.values.map {|facts| facts.name}
   end
 
 
   it "should return node names that match the search query options with the greater than operator" do
-    matching, request = setup_search_matching({
+    assert_search_matches({
         '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '5'),
         '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '10', 'randomfact' => 'foo')
       },
@@ -60,12 +58,10 @@ describe Puppet::Node::Inventory::Yaml do
       },
       {'facts.processor_count.gt' => '4'}
     )
-
-    Puppet::Node::Inventory::Yaml.new.search(request).should =~ matching.values.map {|facts| facts.name}
   end
 
   it "should return node names that match the search query options with the less than operator" do
-    matching, request = setup_search_matching({
+    assert_search_matches({
         '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '5'),
         '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '30', 'randomfact' => 'foo')
       },
@@ -76,12 +72,10 @@ describe Puppet::Node::Inventory::Yaml do
       },
       {'facts.processor_count.lt' => '50'}
     )
-
-    Puppet::Node::Inventory::Yaml.new.search(request).should =~ matching.values.map {|facts| facts.name}
   end
 
   it "should return node names that match the search query options with the less than or equal to operator" do
-    matching, request = setup_search_matching({
+    assert_search_matches({
         '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '5'),
         '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '50', 'randomfact' => 'foo')
       },
@@ -92,12 +86,10 @@ describe Puppet::Node::Inventory::Yaml do
       },
       {'facts.processor_count.le' => '50'}
     )
-
-    Puppet::Node::Inventory::Yaml.new.search(request).should =~ matching.values.map {|facts| facts.name}
   end
 
   it "should return node names that match the search query options with the greater than or equal to operator" do
-    matching, request = setup_search_matching({
+    assert_search_matches({
         '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '100'),
         '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '50', 'randomfact' => 'foo')
       },
@@ -108,12 +100,10 @@ describe Puppet::Node::Inventory::Yaml do
       },
       {'facts.processor_count.ge' => '50'}
     )
-
-    Puppet::Node::Inventory::Yaml.new.search(request).should =~ matching.values.map {|facts| facts.name}
   end
 
   it "should return node names that match the search query options with the not equal operator" do
-    matching, request = setup_search_matching({
+    assert_search_matches({
         '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => 'arm'                           ),
         '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => 'powerpc', 'randomfact' => 'foo')
       },
@@ -124,7 +114,5 @@ describe Puppet::Node::Inventory::Yaml do
       },
       {'facts.architecture.ne' => 'i386'}
     )
-
-    Puppet::Node::Inventory::Yaml.new.search(request).should =~ matching.values.map {|facts| facts.name}
   end
 end
-- 
cgit 


From e6870f6d87b354e30a537eff4a8e98120c05d693 Mon Sep 17 00:00:00 2001
From: Paul Berry <paul@puppetlabs.com>
Date: Mon, 1 Nov 2010 13:46:21 -0700
Subject: (#5166) Inventory service is now searchable by timestamp.
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

It is now possible to specify queries in the form “meta.timestamp.xx”
where xx is eq,ne,gt,lt,ge,le when searching the inventory service.
---
 spec/unit/indirector/inventory/yaml_spec.rb | 103 ++++++++++++++++++++++++++++
 1 file changed, 103 insertions(+)

(limited to 'spec')

diff --git a/spec/unit/indirector/inventory/yaml_spec.rb b/spec/unit/indirector/inventory/yaml_spec.rb
index a595f8a43..9f0c54353 100644
--- a/spec/unit/indirector/inventory/yaml_spec.rb
+++ b/spec/unit/indirector/inventory/yaml_spec.rb
@@ -115,4 +115,107 @@ describe Puppet::Node::Inventory::Yaml do
       {'facts.architecture.ne' => 'i386'}
     )
   end
+
+  def apply_timestamp(facts, timestamp)
+    facts.timestamp = timestamp
+    facts
+  end
+
+  it "should be able to query based on meta.timestamp.gt" do
+    assert_search_matches({
+        '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+        '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+      },
+      {
+        '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+        '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+        '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+      },
+      {'meta.timestamp.gt' => '2010-10-15'}
+    )
+  end
+
+  it "should be able to query based on meta.timestamp.le" do
+    assert_search_matches({
+        '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+        '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+        '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+      },
+      {
+        '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+        '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+      },
+      {'meta.timestamp.le' => '2010-10-15'}
+    )
+  end
+
+  it "should be able to query based on meta.timestamp.lt" do
+    assert_search_matches({
+        '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+        '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+      },
+      {
+        '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+        '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+        '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+      },
+      {'meta.timestamp.lt' => '2010-10-15'}
+    )
+  end
+
+  it "should be able to query based on meta.timestamp.ge" do
+    assert_search_matches({
+        '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+        '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+        '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+      },
+      {
+        '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+        '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+      },
+      {'meta.timestamp.ge' => '2010-10-15'}
+    )
+  end
+
+  it "should be able to query based on meta.timestamp.eq" do
+    assert_search_matches({
+        '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+      },
+      {
+        '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+        '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+        '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+        '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+      },
+      {'meta.timestamp.eq' => '2010-10-15'}
+    )
+  end
+
+  it "should be able to query based on meta.timestamp" do
+    assert_search_matches({
+        '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+      },
+      {
+        '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+        '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+        '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+        '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+      },
+      {'meta.timestamp' => '2010-10-15'}
+    )
+  end
+
+  it "should be able to query based on meta.timestamp.ne" do
+    assert_search_matches({
+        '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+        '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+        '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+        '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+      },
+      {
+        '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+      },
+      {'meta.timestamp.ne' => '2010-10-15'}
+    )
+  end
 end
-- 
cgit 


From d1f1858ea52d3089fd2088994e80d6f49d7e0347 Mon Sep 17 00:00:00 2001
From: Max Martin <max@puppetlabs.com>
Date: Fri, 18 Feb 2011 15:19:46 -0800
Subject: (#6376) Add support and testing for _search GET requests

Added support for adding "_search" to the end of any indirection to
'pluralize' it, and added tests to check this functionality and to test
hidden side effect of plurality method unpluralizing indirections.

Paired-With:Paul Berry <paul@puppetlabs.com>
---
 spec/unit/network/http/api/v1_spec.rb | 12 ++++++++++++
 1 file changed, 12 insertions(+)

(limited to 'spec')

diff --git a/spec/unit/network/http/api/v1_spec.rb b/spec/unit/network/http/api/v1_spec.rb
index d47fc8d81..e7348312b 100644
--- a/spec/unit/network/http/api/v1_spec.rb
+++ b/spec/unit/network/http/api/v1_spec.rb
@@ -88,6 +88,18 @@ describe Puppet::Network::HTTP::API::V1 do
       @tester.uri2indirection("GET", "/env/inventory/search", {}).method.should == :search
     end
 
+    it "should choose 'search' as the indirection method if the http method is a GET and the indirection name is facts_search" do
+      @tester.uri2indirection("GET", "/env/facts_search/bar", {}).method.should == :search
+    end
+
+    it "should change indirection name to 'facts' if the http method is a GET and the indirection name is facts_search" do
+      @tester.uri2indirection("GET", "/env/facts_search/bar", {}).indirection_name.should == :facts
+    end
+
+    it "should change indirection name to 'status' if the http method is a GEt and the indirection name is statuses" do
+      @tester.uri2indirection("GET", "/env/statuses/bar", {}).indirection_name.should == :status
+    end
+
     it "should choose 'delete' as the indirection method if the http method is a DELETE and the indirection name is singular" do
       @tester.uri2indirection("DELETE", "/env/foo/bar", {}).method.should == :destroy
     end
-- 
cgit 


From 6cb365a887d47606bdfae0ff540038b0c49b7451 Mon Sep 17 00:00:00 2001
From: Jacob Helwig <jacob@puppetlabs.com>
Date: Thu, 17 Feb 2011 11:52:45 -0800
Subject: (#6309) Ensure the correct device is mounted when managing mounts

Previously the mount type would only check if anything was mounted at the
desired point, when 'ensure => mounted' was specified.  Now we check not
only whether something is mounted at the desired point, but also that it
is the thing we wish to be mounted there.

There is also a chance that the mount point directory could be
"automagically" removed for us, when unmounting incorrect devices, so we
attempt to re-create the directory after unmounting to give the mount of
the correct device a better chance at succeeding.

Paired-with: Matt Robinson <matt@puppetlabs.com>
Paired-with: Nick Lewis <nick@puppetlabs.com>
Paired-with: Jesse Wolfe <jesse@puppetlabs.com>
---
 .../unit/provider/mount/mount-output.darwin.txt    |   5 +
 .../unit/provider/mount/mount-output.hp-ux.txt     |  16 ++
 .../unit/provider/mount/mount-output.other.txt     |  14 ++
 .../unit/provider/mount/mount-output.solaris.txt   |  16 ++
 spec/unit/provider/mount/parsed_spec.rb            |   4 +-
 spec/unit/provider/mount_spec.rb                   | 185 ++++++++++++++-------
 spec/unit/type/mount_spec.rb                       |  56 ++-----
 7 files changed, 191 insertions(+), 105 deletions(-)
 create mode 100644 spec/fixtures/unit/provider/mount/mount-output.darwin.txt
 create mode 100644 spec/fixtures/unit/provider/mount/mount-output.hp-ux.txt
 create mode 100644 spec/fixtures/unit/provider/mount/mount-output.other.txt
 create mode 100644 spec/fixtures/unit/provider/mount/mount-output.solaris.txt

(limited to 'spec')

diff --git a/spec/fixtures/unit/provider/mount/mount-output.darwin.txt b/spec/fixtures/unit/provider/mount/mount-output.darwin.txt
new file mode 100644
index 000000000..fbb9d9832
--- /dev/null
+++ b/spec/fixtures/unit/provider/mount/mount-output.darwin.txt
@@ -0,0 +1,5 @@
+/dev/disk0s2 on / (hfs, local, journaled)
+devfs on /dev (devfs, local, nobrowse)
+map -hosts on /net (autofs, nosuid, automounted, nobrowse)
+map auto_home on /home (autofs, automounted, nobrowse)
+/dev/disk0s3 on /usr (hfs, local, journaled)
diff --git a/spec/fixtures/unit/provider/mount/mount-output.hp-ux.txt b/spec/fixtures/unit/provider/mount/mount-output.hp-ux.txt
new file mode 100644
index 000000000..477926138
--- /dev/null
+++ b/spec/fixtures/unit/provider/mount/mount-output.hp-ux.txt
@@ -0,0 +1,16 @@
+/ on rpool/ROOT/opensolaris read/write/setuid/devices/dev=2d90002 on Wed Dec 31 16:00:00 1969
+/devices on /devices read/write/setuid/devices/dev=4a00000 on Thu Feb 17 14:34:02 2011
+/dev on /dev read/write/setuid/devices/dev=4a40000 on Thu Feb 17 14:34:02 2011
+/system/contract on ctfs read/write/setuid/devices/dev=4ac0001 on Thu Feb 17 14:34:02 2011
+/proc on proc read/write/setuid/devices/dev=4b00000 on Thu Feb 17 14:34:02 2011
+/etc/mnttab on mnttab read/write/setuid/devices/dev=4b40001 on Thu Feb 17 14:34:02 2011
+/etc/svc/volatile on swap read/write/setuid/devices/xattr/dev=4b80001 on Thu Feb 17 14:34:02 2011
+/system/object on objfs read/write/setuid/devices/dev=4bc0001 on Thu Feb 17 14:34:02 2011
+/etc/dfs/sharetab on sharefs read/write/setuid/devices/dev=4c00001 on Thu Feb 17 14:34:02 2011
+/lib/libc.so.1 on /usr/lib/libc/libc_hwcap1.so.1 read/write/setuid/devices/dev=2d90002 on Thu Feb 17 14:34:14 2011
+/dev/fd on fd read/write/setuid/devices/dev=4d00001 on Thu Feb 17 14:34:18 2011
+/tmp on swap read/write/setuid/devices/xattr/dev=4b80002 on Thu Feb 17 14:34:19 2011
+/var/run on swap read/write/setuid/devices/xattr/dev=4b80003 on Thu Feb 17 14:34:19 2011
+/export on rpool/export read/write/setuid/devices/nonbmand/exec/xattr/atime/dev=2d90006 on Thu Feb 17 14:37:48 2011
+/export/home on rpool/export/home read/write/setuid/devices/nonbmand/exec/xattr/atime/dev=2d90007 on Thu Feb 17 14:37:48 2011
+/rpool on rpool read/write/setuid/devices/nonbmand/exec/xattr/atime/dev=2d90009 on Thu Feb 17 14:37:48 2011
diff --git a/spec/fixtures/unit/provider/mount/mount-output.other.txt b/spec/fixtures/unit/provider/mount/mount-output.other.txt
new file mode 100644
index 000000000..0e4dff0c5
--- /dev/null
+++ b/spec/fixtures/unit/provider/mount/mount-output.other.txt
@@ -0,0 +1,14 @@
+/dev/sda1 on / type ext4 (rw,errors=remount-ro,commit=0)
+proc on /proc type proc (rw,noexec,nosuid,nodev)
+none on /sys type sysfs (rw,noexec,nosuid,nodev)
+fusectl on /sys/fs/fuse/connections type fusectl (rw)
+none on /sys/kernel/debug type debugfs (rw)
+none on /sys/kernel/security type securityfs (rw)
+none on /dev type devtmpfs (rw,mode=0755)
+none on /dev/pts type devpts (rw,noexec,nosuid,gid=5,mode=0620)
+none on /dev/shm type tmpfs (rw,nosuid,nodev)
+none on /var/run type tmpfs (rw,nosuid,mode=0755)
+none on /var/lock type tmpfs (rw,noexec,nosuid,nodev)
+none on /proc/fs/vmblock/mountPoint type vmblock (rw)
+binfmt_misc on /proc/sys/fs/binfmt_misc type binfmt_misc (rw,noexec,nosuid,nodev)
+/dev/sda2 on /usr type ext4 (rw,errors=remount-ro,commit=0)
diff --git a/spec/fixtures/unit/provider/mount/mount-output.solaris.txt b/spec/fixtures/unit/provider/mount/mount-output.solaris.txt
new file mode 100644
index 000000000..477926138
--- /dev/null
+++ b/spec/fixtures/unit/provider/mount/mount-output.solaris.txt
@@ -0,0 +1,16 @@
+/ on rpool/ROOT/opensolaris read/write/setuid/devices/dev=2d90002 on Wed Dec 31 16:00:00 1969
+/devices on /devices read/write/setuid/devices/dev=4a00000 on Thu Feb 17 14:34:02 2011
+/dev on /dev read/write/setuid/devices/dev=4a40000 on Thu Feb 17 14:34:02 2011
+/system/contract on ctfs read/write/setuid/devices/dev=4ac0001 on Thu Feb 17 14:34:02 2011
+/proc on proc read/write/setuid/devices/dev=4b00000 on Thu Feb 17 14:34:02 2011
+/etc/mnttab on mnttab read/write/setuid/devices/dev=4b40001 on Thu Feb 17 14:34:02 2011
+/etc/svc/volatile on swap read/write/setuid/devices/xattr/dev=4b80001 on Thu Feb 17 14:34:02 2011
+/system/object on objfs read/write/setuid/devices/dev=4bc0001 on Thu Feb 17 14:34:02 2011
+/etc/dfs/sharetab on sharefs read/write/setuid/devices/dev=4c00001 on Thu Feb 17 14:34:02 2011
+/lib/libc.so.1 on /usr/lib/libc/libc_hwcap1.so.1 read/write/setuid/devices/dev=2d90002 on Thu Feb 17 14:34:14 2011
+/dev/fd on fd read/write/setuid/devices/dev=4d00001 on Thu Feb 17 14:34:18 2011
+/tmp on swap read/write/setuid/devices/xattr/dev=4b80002 on Thu Feb 17 14:34:19 2011
+/var/run on swap read/write/setuid/devices/xattr/dev=4b80003 on Thu Feb 17 14:34:19 2011
+/export on rpool/export read/write/setuid/devices/nonbmand/exec/xattr/atime/dev=2d90006 on Thu Feb 17 14:37:48 2011
+/export/home on rpool/export/home read/write/setuid/devices/nonbmand/exec/xattr/atime/dev=2d90007 on Thu Feb 17 14:37:48 2011
+/rpool on rpool read/write/setuid/devices/nonbmand/exec/xattr/atime/dev=2d90009 on Thu Feb 17 14:37:48 2011
diff --git a/spec/unit/provider/mount/parsed_spec.rb b/spec/unit/provider/mount/parsed_spec.rb
index 5a1c986b1..78a44322e 100755
--- a/spec/unit/provider/mount/parsed_spec.rb
+++ b/spec/unit/provider/mount/parsed_spec.rb
@@ -130,7 +130,7 @@ describe provider_class do
       mount.stubs(:mountcmd) # just so we don't actually try to mount anything
 
       mount.expects(:flush)
-      mount.mount
+      mount.mount!
     end
   end
 
@@ -176,7 +176,7 @@ describe provider_class do
 
     it "should determine that the root fs is mounted" do
       @provider_class.prefetch("/" => @mount)
-      @mount.provider.should be_mounted
+      @mount.provider.should be_anything_mounted
     end
   end
 
diff --git a/spec/unit/provider/mount_spec.rb b/spec/unit/provider/mount_spec.rb
index f567a4a40..1f2501765 100755
--- a/spec/unit/provider/mount_spec.rb
+++ b/spec/unit/provider/mount_spec.rb
@@ -2,28 +2,30 @@
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
+require 'puppet_spec/files'
 require 'puppet/provider/mount'
 
 describe Puppet::Provider::Mount do
-  before :each do
-    @mounter = Object.new
-    @mounter.extend(Puppet::Provider::Mount)
+  include PuppetSpec::Files
 
+  before :each do
     @name = "/"
 
-    @resource = stub 'resource'
-    @resource.stubs(:[]).with(:name).returns(@name)
+    @resource = Puppet::Type.type(:mount).new(
+      :name => '/',
+      :device => '/dev/sda1',
+      :target => tmpfile("mount_provider")
+    )
 
-    @mounter.stubs(:resource).returns(@resource)
+    @mounter = Puppet::Type.type(:mount).defaultprovider().new(@resource)
   end
 
-  describe Puppet::Provider::Mount, " when mounting" do
-
+  describe "when calling mount!" do
     it "should use the 'mountcmd' method to mount" do
       @mounter.stubs(:options).returns(nil)
       @mounter.expects(:mountcmd)
 
-      @mounter.mount
+      @mounter.mount!
     end
 
     it "should flush before mounting if a flush method exists" do
@@ -32,114 +34,169 @@ describe Puppet::Provider::Mount do
       @mounter.stubs(:mountcmd)
       @mounter.stubs(:options).returns(nil)
 
-      @mounter.mount
+      @mounter.mount!
     end
 
     it "should add the options following '-o' if they exist and are not set to :absent" do
       @mounter.stubs(:options).returns("ro")
       @mounter.expects(:mountcmd).with { |*ary| ary[0] == "-o" and ary[1] == "ro" }
 
-      @mounter.mount
+      @mounter.mount!
     end
 
     it "should specify the filesystem name to the mount command" do
       @mounter.stubs(:options).returns(nil)
       @mounter.expects(:mountcmd).with { |*ary| ary[-1] == @name }
 
-      @mounter.mount
+      @mounter.mount!
     end
   end
 
-  describe Puppet::Provider::Mount, " when remounting" do
-
+  describe "when remounting" do
     it "should use '-o remount' if the resource specifies it supports remounting" do
       @mounter.stubs(:info)
-      @resource.stubs(:[]).with(:remounts).returns(:true)
+      @resource[:remounts] = true
       @mounter.expects(:mountcmd).with("-o", "remount", @name)
       @mounter.remount
     end
 
     it "should unmount and mount if the resource does not specify it supports remounting" do
       @mounter.stubs(:info)
-      @resource.stubs(:[]).with(:remounts).returns(false)
+      @resource[:remounts] = false
       @mounter.expects(:unmount)
       @mounter.expects(:mount)
       @mounter.remount
     end
 
     it "should log that it is remounting" do
-      @resource.stubs(:[]).with(:remounts).returns(:true)
+      @resource[:remounts] = true
       @mounter.stubs(:mountcmd)
       @mounter.expects(:info).with("Remounting")
       @mounter.remount
     end
   end
 
-  describe Puppet::Provider::Mount, " when unmounting" do
-
+  describe "when unmounting" do
     it "should call the :umount command with the resource name" do
       @mounter.expects(:umount).with(@name)
       @mounter.unmount
     end
   end
 
-  describe Puppet::Provider::Mount, " when determining if it is mounted" do
-
-    it "should parse the results of running the mount command with no arguments" do
-      Facter.stubs(:value).returns("whatever")
-      @mounter.expects(:mountcmd).returns("")
-
-      @mounter.mounted?
-    end
-
-    it "should match ' on /private/var/automount<name>' if the operating system is Darwin" do
-      Facter.stubs(:value).with("operatingsystem").returns("Darwin")
-      @mounter.expects(:mountcmd).returns("/dev/whatever on /private/var/automount/\ndevfs on /dev")
-
-      @mounter.should be_mounted
+  %w{Darwin Solaris HP-UX AIX Other}.each do |platform|
+    describe "on #{platform}" do
+      before :each do
+        case platform
+        when 'Darwin'
+          mount_fixture = 'mount-output.darwin.txt'
+          @mount_device = '/dev/disk0s3'
+          @mount_point = '/usr'
+        when 'Solaris'
+          mount_fixture = 'mount-output.solaris.txt'
+          @mount_device = 'swap'
+          @mount_point = '/tmp'
+        when 'HP-UX'
+          mount_fixture = 'mount-output.hp-ux.txt'
+          @mount_device = 'swap'
+          @mount_point = '/tmp'
+        when 'AIX'
+          mount_fixture = 'mount-output.aix.txt'
+          @mount_device = '/dev/hd2'
+          @mount_point = '/usr'
+        when 'Other'
+          mount_fixture = 'mount-output.other.txt'
+          @mount_device = '/dev/sda2'
+          @mount_point = '/usr'
+        end
+        @mount_data = File.read(File.join(File.dirname(__FILE__), '..', '..', 'fixtures', 'unit', 'provider', 'mount', mount_fixture))
+        Facter.stubs(:value).with("operatingsystem").returns(platform)
+      end
+
+      describe "when the correct thing is mounted" do
+        before :each do
+          @mounter.expects(:mountcmd).returns(@mount_data)
+          @resource.stubs(:[]).with(:name).returns(@mount_point)
+          @resource.stubs(:[]).with(:device).returns(@mount_device)
+        end
+
+        it "should say anything_mounted?" do
+          @mounter.should be_anything_mounted
+        end
+
+        it "should say correctly_mounted?" do
+          @mounter.should be_correctly_mounted
+        end
+      end
+
+      describe "when the wrong thing is mounted" do
+        before :each do
+          @mounter.expects(:mountcmd).returns(@mount_data)
+          @resource.stubs(:[]).with(:name).returns(@mount_point)
+          @resource.stubs(:[]).with(:device).returns('/dev/bogus/thing')
+        end
+
+        it "should say anything_mounted?" do
+          @mounter.should be_anything_mounted
+        end
+
+        it "should not say correctly_mounted?" do
+          @mounter.should_not be_correctly_mounted
+        end
+      end
+
+      describe "when nothing is mounted" do
+        before :each do
+          @mounter.expects(:mountcmd).returns(@mount_data)
+          @resource.stubs(:[]).with(:name).returns('/bogus/location')
+          @resource.stubs(:[]).with(:device).returns(@mount_device)
+        end
+
+        it "should not say anything_mounted?" do
+          @mounter.should_not be_anything_mounted
+        end
+
+        it "should not say correctly_mounted?" do
+          @mounter.should_not be_correctly_mounted
+        end
+      end
     end
+  end
 
-    it "should match ' on <name>' if the operating system is Darwin" do
-      Facter.stubs(:value).with("operatingsystem").returns("Darwin")
-      @mounter.expects(:mountcmd).returns("/dev/disk03 on / (local, journaled)\ndevfs on /dev")
-
-      @mounter.should be_mounted
-    end
+  describe "when mounting a device" do
+    it "should not mount! or unmount anything when the correct device is mounted" do
+      @mounter.stubs(:correctly_mounted?).returns(true)
 
-    it "should match '^<name> on' if the operating system is Solaris" do
-      Facter.stubs(:value).with("operatingsystem").returns("Solaris")
-      @mounter.expects(:mountcmd).returns("/ on /dev/dsk/whatever\n/var on /dev/dsk/other")
+      @mounter.expects(:anything_mounted?).never
+      @mounter.expects(:create).once
+      @mounter.expects(:mount!).never
+      @mounter.expects(:unmount).never
+      FileUtils.expects(:mkdir_p).never
 
-      @mounter.should be_mounted
+      @mounter.mount
     end
 
-    it "should match '^<name> on' if the operating system is HP-UX" do
-      Facter.stubs(:value).with("operatingsystem").returns("HP-UX")
-      @mounter.expects(:mountcmd).returns("/ on /dev/dsk/whatever\n/var on /dev/dsk/other")
+    it "should mount the device when nothing is mounted at the desired point" do
+      @mounter.stubs(:correctly_mounted?).returns(false)
+      @mounter.stubs(:anything_mounted?).returns(false)
 
-      @mounter.should be_mounted
-    end
-
-    it "should match mounted devices if the operating system is AIX" do
-      Facter.stubs(:value).with("operatingsystem").returns("AIX")
-      mount_data = File.read(File.join(File.dirname(__FILE__), '..', '..', 'fixtures', 'unit', 'provider', 'mount', 'mount-output.aix.txt'))
-      @mounter.expects(:mountcmd).returns(mount_data)
+      @mounter.expects(:create).once
+      @mounter.expects(:mount!).once
+      @mounter.expects(:unmount).never
+      FileUtils.expects(:mkdir_p).never
 
-      @mounter.should be_mounted
+      @mounter.mount
     end
 
-    it "should match ' on <name>' if the operating system is not Darwin, Solaris, or HP-UX" do
-      Facter.stubs(:value).with("operatingsystem").returns("Debian")
-      @mounter.expects(:mountcmd).returns("/dev/dsk/whatever on / and stuff\n/dev/other/disk on /var and stuff")
+    it "should unmount the incorrect device and mount the correct device" do
+      @mounter.stubs(:correctly_mounted?).returns(false)
+      @mounter.stubs(:anything_mounted?).returns(true)
 
-      @mounter.should be_mounted
-    end
-
-    it "should not be considered mounted if it did not match the mount output" do
-      Facter.stubs(:value).with("operatingsystem").returns("Debian")
-      @mounter.expects(:mountcmd).returns("/dev/dsk/whatever on /something/else and stuff\n/dev/other/disk on /var and stuff")
+      @mounter.expects(:create).once
+      @mounter.expects(:mount!).once
+      @mounter.expects(:unmount).once
+      FileUtils.expects(:mkdir_p).with(@name).returns(true)
 
-      @mounter.should_not be_mounted
+      @mounter.mount
     end
   end
 end
diff --git a/spec/unit/type/mount_spec.rb b/spec/unit/type/mount_spec.rb
index 0d74042e3..c6d2b5ba0 100755
--- a/spec/unit/type/mount_spec.rb
+++ b/spec/unit/type/mount_spec.rb
@@ -74,8 +74,7 @@ describe Puppet::Type.type(:mount)::Ensure do
     end
   end
 
-  describe Puppet::Type.type(:mount)::Ensure, "when retrieving its current state" do
-
+  describe "when retrieving its current state" do
     it "should return the provider's value if it is :absent" do
       @provider.expects(:ensure).returns(:absent)
       @ensure.retrieve.should == :absent
@@ -83,28 +82,27 @@ describe Puppet::Type.type(:mount)::Ensure do
 
     it "should return :mounted if the provider indicates it is mounted and the value is not :absent" do
       @provider.expects(:ensure).returns(:present)
-      @provider.expects(:mounted?).returns(true)
+      @provider.expects(:correctly_mounted?).returns(true)
       @ensure.retrieve.should == :mounted
     end
 
     it "should return :unmounted if the provider indicates it is not mounted and the value is not :absent" do
       @provider.expects(:ensure).returns(:present)
-      @provider.expects(:mounted?).returns(false)
+      @provider.expects(:correctly_mounted?).returns(false)
       @ensure.retrieve.should == :unmounted
     end
   end
 
-  describe Puppet::Type.type(:mount)::Ensure, "when changing the host" do
-
+  describe "when changing the host" do
     it "should destroy itself if it should be absent" do
-      @provider.stubs(:mounted?).returns(false)
+      @provider.stubs(:anything_mounted?).returns(false)
       @provider.expects(:destroy)
       @ensure.should = :absent
       @ensure.sync
     end
 
     it "should unmount itself before destroying if it is mounted and should be absent" do
-      @provider.expects(:mounted?).returns(true)
+      @provider.expects(:anything_mounted?).returns(true)
       @provider.expects(:unmount)
       @provider.expects(:destroy)
       @ensure.should = :absent
@@ -113,9 +111,9 @@ describe Puppet::Type.type(:mount)::Ensure do
 
     it "should create itself if it is absent and should be defined" do
       @provider.stubs(:ensure).returns(:absent)
-      @provider.stubs(:mounted?).returns(true)
+      @provider.stubs(:anything_mounted?).returns(true)
 
-      @provider.stubs(:mounted?).returns(false)
+      @provider.stubs(:anything_mounted?).returns(false)
       @provider.expects(:create)
       @ensure.should = :defined
       @ensure.sync
@@ -123,7 +121,7 @@ describe Puppet::Type.type(:mount)::Ensure do
 
     it "should not unmount itself if it is mounted and should be defined" do
       @provider.stubs(:ensure).returns(:mounted)
-      @provider.stubs(:mounted?).returns(true)
+      @provider.stubs(:anything_mounted?).returns(true)
 
       @provider.stubs(:create)
       @provider.expects(:mount).never
@@ -134,7 +132,7 @@ describe Puppet::Type.type(:mount)::Ensure do
 
     it "should not mount itself if it is unmounted and should be defined" do
       @provider.stubs(:ensure).returns(:unmounted)
-      @provider.stubs(:mounted?).returns(false)
+      @provider.stubs(:anything_mounted?).returns(false)
 
       @ensure.stubs(:syncothers)
       @provider.stubs(:create)
@@ -146,7 +144,7 @@ describe Puppet::Type.type(:mount)::Ensure do
 
     it "should unmount itself if it is mounted and should be unmounted" do
       @provider.stubs(:ensure).returns(:present)
-      @provider.stubs(:mounted?).returns(true)
+      @provider.stubs(:anything_mounted?).returns(true)
 
       @ensure.stubs(:syncothers)
       @provider.expects(:unmount)
@@ -154,34 +152,14 @@ describe Puppet::Type.type(:mount)::Ensure do
       @ensure.sync
     end
 
-    it "should create and mount itself if it does not exist and should be mounted" do
-      @provider.stubs(:ensure).returns(:absent)
-      @provider.stubs(:mounted?).returns(false)
-      @provider.expects(:create)
-      @ensure.stubs(:syncothers)
-      @provider.expects(:mount)
-      @ensure.should = :mounted
-      @ensure.sync
-    end
-
-    it "should mount itself if it is present and should be mounted" do
+    it "should ask the provider to mount itself" do
       @provider.stubs(:ensure).returns(:present)
-      @provider.stubs(:mounted?).returns(false)
       @ensure.stubs(:syncothers)
       @provider.expects(:mount)
       @ensure.should = :mounted
       @ensure.sync
     end
 
-    it "should create but not mount itself if it is absent and mounted and should be mounted" do
-      @provider.stubs(:ensure).returns(:absent)
-      @provider.stubs(:mounted?).returns(true)
-      @ensure.stubs(:syncothers)
-      @provider.expects(:create)
-      @ensure.should = :mounted
-      @ensure.sync
-    end
-
     it "should be insync if it is mounted and should be defined" do
       @ensure.should = :defined
       @ensure.safe_insync?(:mounted).should == true
@@ -203,17 +181,16 @@ describe Puppet::Type.type(:mount)::Ensure do
     end
   end
 
-  describe Puppet::Type.type(:mount), "when responding to events" do
-
+  describe "when responding to events" do
     it "should remount if it is currently mounted" do
-      @provider.expects(:mounted?).returns(true)
+      @provider.expects(:anything_mounted?).returns(true)
       @provider.expects(:remount)
 
       @mount.refresh
     end
 
     it "should not remount if it is not currently mounted" do
-      @provider.expects(:mounted?).returns(false)
+      @provider.expects(:anything_mounted?).returns(false)
       @provider.expects(:remount).never
 
       @mount.refresh
@@ -241,7 +218,8 @@ describe Puppet::Type.type(:mount), "when modifying an existing mount entry" do
       @mount[param] = value
     end
 
-    @mount.provider.stubs(:mounted?).returns true
+    @mount.provider.stubs(:anything_mounted?).returns true
+    @mount.provider.stubs(:correctly_mounted?).returns true
 
     # stub this to not try to create state.yaml
     Puppet::Util::Storage.stubs(:store)
-- 
cgit 


From e85420585158ab1a74727efcff449190f6d84899 Mon Sep 17 00:00:00 2001
From: Jacob Helwig <jacob@puppetlabs.com>
Date: Fri, 18 Feb 2011 15:26:58 -0800
Subject: Remove pending tests from parsed mount provider

Paired-with: Jesse Wolfe <jesse@puppetlabs.com>
---
 spec/unit/provider/mount/parsed_spec.rb | 10 ----------
 1 file changed, 10 deletions(-)

(limited to 'spec')

diff --git a/spec/unit/provider/mount/parsed_spec.rb b/spec/unit/provider/mount/parsed_spec.rb
index 78a44322e..069d9495a 100755
--- a/spec/unit/provider/mount/parsed_spec.rb
+++ b/spec/unit/provider/mount/parsed_spec.rb
@@ -179,14 +179,4 @@ describe provider_class do
       @mount.provider.should be_anything_mounted
     end
   end
-
-  describe provider_class, " when mounting and unmounting" do
-    include ParsedMountTesting
-
-    it "should call the 'mount' command to mount the filesystem"
-
-    it "should call the 'unmount' command to unmount the filesystem"
-
-    it "should specify the filesystem when remounting a filesystem"
-  end
 end
-- 
cgit 


From ec33a09cc4b2caf391e07f21603e86d81c861b78 Mon Sep 17 00:00:00 2001
From: Stefan Schulte <stefan.schulte@taunusstein.net>
Date: Sun, 20 Feb 2011 11:08:34 +0100
Subject: (#4914) Remove mount specs

Remove mount specs that seem to only test if the parsedfile provider is
working correctly or are obsolete specs.
---
 spec/unit/provider/mount/parsed_spec.rb | 83 ++-------------------------------
 1 file changed, 3 insertions(+), 80 deletions(-)

(limited to 'spec')

diff --git a/spec/unit/provider/mount/parsed_spec.rb b/spec/unit/provider/mount/parsed_spec.rb
index 5a1c986b1..94e731bec 100755
--- a/spec/unit/provider/mount/parsed_spec.rb
+++ b/spec/unit/provider/mount/parsed_spec.rb
@@ -5,15 +5,17 @@
 
 require File.dirname(__FILE__) + '/../../../spec_helper'
 
+require 'puppet_spec/files'
 require 'puppettest/support/utils'
 require 'puppettest/fileparsing'
 
 module ParsedMountTesting
   include PuppetTest::Support::Utils
   include PuppetTest::FileParsing
+  include PuppetSpec::Files
 
   def fake_fstab
-    os = Facter['operatingsystem']
+    os = Facter.value(:operatingsystem)
     if os == "Solaris"
       name = "solaris.fstab"
     elsif os == "FreeBSD"
@@ -22,51 +24,10 @@ module ParsedMountTesting
       # Catchall for other fstabs
       name = "linux.fstab"
     end
-    oldpath = @provider_class.default_target
     fakefile(File::join("data/types/mount", name))
   end
 
-  def mkmountargs
-    mount = nil
 
-    if defined?(@pcount)
-      @pcount += 1
-    else
-      @pcount = 1
-    end
-    args = {
-      :name => "/fspuppet#{@pcount}",
-      :device => "/dev/dsk#{@pcount}",
-    }
-
-    @provider_class.fields(:parsed).each do |field|
-      args[field] = "fake#{field}#{@pcount}" unless args.include? field
-    end
-
-    args
-  end
-
-  def mkmount
-    hash = mkmountargs
-    #hash[:provider] = @provider_class.name
-
-    fakeresource = stub :type => :mount, :name => hash[:name]
-    fakeresource.stubs(:[]).with(:name).returns(hash[:name])
-    fakeresource.stubs(:should).with(:target).returns(nil)
-
-    mount = @provider_class.new(fakeresource)
-    hash[:record_type] = :parsed
-    hash[:ensure] = :present
-    mount.property_hash = hash
-
-    mount
-  end
-
-  # Here we just create a fake host type that answers to all of the methods
-  # but does not modify our actual system.
-  def mkfaketype
-    @provider.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
-  end
 end
 
 provider_class = Puppet::Type.type(:mount).provider(:parsed)
@@ -117,45 +78,7 @@ describe provider_class do
     end
   end
 
-  describe provider_class, " when mounting an absent filesystem" do
-    include ParsedMountTesting
-
-    # #730 - Make sure 'flush' is called when a mount is moving from absent to mounted
-    it "should flush the fstab to disk" do
-      mount = mkmount
-
-      # Mark the mount as absent
-      mount.property_hash[:ensure] = :absent
-
-      mount.stubs(:mountcmd) # just so we don't actually try to mount anything
-
-      mount.expects(:flush)
-      mount.mount
-    end
-  end
-
-  describe provider_class, " when modifying the filesystem tab" do
-    include ParsedMountTesting
-    before do
-      Puppet.settings.stubs(:use)
-      # Never write to disk, only to RAM.
-      #@provider_class.stubs(:filetype).returns(Puppet::Util::FileType.filetype(:ram))
-      @provider_class.stubs(:target_object).returns(Puppet::Util::FileType.filetype(:ram).new("eh"))
-      @provider_class.clear
-
-      @mount = mkmount
-      @target = @provider_class.default_target
-    end
-
-    it "should write the mount to disk when :flush is called" do
-      old_text = @provider_class.target_object(@provider_class.default_target).read
 
-      @mount.flush
-
-      text = @provider_class.target_object(@provider_class.default_target).read
-      text.should == old_text + @mount.class.to_line(@mount.property_hash) + "\n"
-    end
-  end
 
   describe provider_class, " when parsing information about the root filesystem", :if => Facter["operatingsystem"].value != "Darwin" do
     include ParsedMountTesting
-- 
cgit 


From c57c508e938083115bbc00037901f652505288b0 Mon Sep 17 00:00:00 2001
From: Stefan Schulte <stefan.schulte@taunusstein.net>
Date: Sun, 20 Feb 2011 11:18:19 +0100
Subject: (#4914) Improved parsed_spec for mount

Add specs for the new prefetching and the correct parsing of vfstab on
Solaris and fstab on other systems
---
 spec/unit/provider/mount/parsed_spec.rb | 239 +++++++++++++++++++++++++-------
 1 file changed, 192 insertions(+), 47 deletions(-)

(limited to 'spec')

diff --git a/spec/unit/provider/mount/parsed_spec.rb b/spec/unit/provider/mount/parsed_spec.rb
index 94e731bec..2a305b905 100755
--- a/spec/unit/provider/mount/parsed_spec.rb
+++ b/spec/unit/provider/mount/parsed_spec.rb
@@ -27,89 +27,234 @@ module ParsedMountTesting
     fakefile(File::join("data/types/mount", name))
   end
 
+  def fake_mountoutput
+    os = Facter.value(:operatingsystem)
+    if os == "Darwin"
+      name = "darwin.mount"
+    elsif os == "HP-UX"
+      name = "hpux.mount"
+    elsif os == "Solaris"
+      name = "solaris.mount"
+    else
+      # Catchall for other fstabs
+      name = "linux.mount"
+    end
+    fakefile(File::join("data/providers/mount/parsed", name))
+  end
 
 end
 
 provider_class = Puppet::Type.type(:mount).provider(:parsed)
 
 describe provider_class do
+
   before :each do
     @mount_class = Puppet::Type.type(:mount)
-    @provider_class = @mount_class.provider(:parsed)
+    @provider = @mount_class.provider(:parsed)
   end
 
+  # LAK:FIXME I can't mock Facter because this test happens at parse-time.
+  it "should default to /etc/vfstab on Solaris" do
+    pending "This test only works on Solaris" unless Facter.value(:operatingsystem) == 'Solaris'
+    Puppet::Type.type(:mount).provider(:parsed).default_target.should == '/etc/vfstab'
+  end
 
-  describe provider_class do
-    include ParsedMountTesting
+  it "should default to /etc/fstab on anything else" do
+    pending "This test does not work on Solaris" if Facter.value(:operatingsystem) == 'Solaris'
+    Puppet::Type.type(:mount).provider(:parsed).default_target.should == '/etc/fstab'
+  end
 
-    it "should be able to parse all of the example mount tabs" do
-      tab = fake_fstab
-      @provider = @provider_class
+  describe "when parsing a line" do
 
-      # LAK:FIXME Again, a relatively bad test, but I don't know how to rspec-ify this.
-      # I suppose this is more of an integration test?  I dunno.
-      fakedataparse(tab) do
-        # Now just make we've got some mounts we know will be there
-        hashes = @provider_class.target_records(tab).find_all { |i| i.is_a? Hash }
-        (hashes.length > 0).should be_true
-        root = hashes.find { |i| i[:name] == "/" }
+    it "should not crash on incomplete lines in fstab" do
+      parse = @provider.parse <<-FSTAB
+/dev/incomplete
+/dev/device       name
+FSTAB
+      lambda{ @provider.to_line(parse[0]) }.should_not raise_error
+    end
 
-        proc { @provider_class.to_file(hashes) }.should_not raise_error
+
+    describe "on Solaris", :if => Facter.value(:operatingsystem) == 'Solaris' do
+
+      before :each do
+        @example_line = "/dev/dsk/c0d0s0 /dev/rdsk/c0d0s0 \t\t    /  \t    ufs     1 no\t-"
       end
-    end
 
-    # LAK:FIXME I can't mock Facter because this test happens at parse-time.
-    it "should default to /etc/vfstab on Solaris and /etc/fstab everywhere else" do
-      should = case Facter.value(:operatingsystem)
-        when "Solaris"; "/etc/vfstab"
-        else
-          "/etc/fstab"
-        end
-      Puppet::Type.type(:mount).provider(:parsed).default_target.should == should
-    end
+      it "should extract device from the first field" do
+        @provider.parse_line(@example_line)[:device].should == '/dev/dsk/c0d0s0'
+      end
 
-    it "should not crash on incomplete lines in fstab" do
-      parse = @provider_class.parse <<-FSTAB
-/dev/incomplete
-/dev/device       name
-      FSTAB
+      it "should extract blockdevice from second field" do
+        @provider.parse_line(@example_line)[:blockdevice].should == "/dev/rdsk/c0d0s0"
+      end
+
+      it "should extract name from third field" do
+        @provider.parse_line(@example_line)[:name].should == "/"
+      end
+
+      it "should extract fstype from fourth field" do
+        @provider.parse_line(@example_line)[:fstype].should == "ufs"
+      end
+
+      it "should extract pass from fifth field" do
+        @provider.parse_line(@example_line)[:pass].should == "1"
+      end
+
+      it "should extract atboot from sixth field" do
+        @provider.parse_line(@example_line)[:atboot].should == "no"
+      end
+
+      it "should extract options from seventh field" do
+        @provider.parse_line(@example_line)[:options].should == "-"
+      end
 
-      lambda{ @provider_class.to_line(parse[0]) }.should_not raise_error
     end
-  end
 
+    describe "on other platforms than Solaris", :if => Facter.value(:operatingsystem) != 'Solaris' do
 
+      before :each do
+        @example_line = "/dev/vg00/lv01\t/spare   \t  \t   ext3    defaults\t1 2"
+      end
+
+      it "should extract device from the first field" do
+        @provider.parse_line(@example_line)[:device].should == '/dev/vg00/lv01'
+      end
+
+      it "should extract name from second field" do
+        @provider.parse_line(@example_line)[:name].should == "/spare"
+      end
+
+      it "should extract fstype from third field" do
+        @provider.parse_line(@example_line)[:fstype].should == "ext3"
+      end
+
+      it "should extract options from fourth field" do
+        @provider.parse_line(@example_line)[:options].should == "defaults"
+      end
+
+      it "should extract dump from fifth field" do
+        @provider.parse_line(@example_line)[:dump].should == "1"
+      end
+
+      it "should extract options from sixth field" do
+        @provider.parse_line(@example_line)[:pass].should == "2"
+      end
+
+    end
+
+  end
 
-  describe provider_class, " when parsing information about the root filesystem", :if => Facter["operatingsystem"].value != "Darwin" do
+  describe "mountinstances" do
     include ParsedMountTesting
 
-    before do
-      @mount = @mount_class.new :name => "/"
-      @provider = @mount.provider
+    it "should get name from mountoutput found on Solaris" do
+      Facter.stubs(:value).with(:operatingsystem).returns 'Solaris'
+      @provider.stubs(:mountcmd).returns(File.read(fake_mountoutput))
+      mounts = @provider.mountinstances
+      mounts.size.should == 6
+      mounts[0].should == { :name => '/', :mounted => :yes }
+      mounts[1].should == { :name => '/proc', :mounted => :yes }
+      mounts[2].should == { :name => '/etc/mnttab', :mounted => :yes }
+      mounts[3].should == { :name => '/tmp', :mounted => :yes }
+      mounts[4].should == { :name => '/export/home', :mounted => :yes }
+      mounts[5].should == { :name => '/ghost', :mounted => :yes }
+    end
+
+    it "should get name from mountoutput found on HP-UX" do
+      Facter.stubs(:value).with(:operatingsystem).returns 'HP-UX'
+      @provider.stubs(:mountcmd).returns(File.read(fake_mountoutput))
+      mounts = @provider.mountinstances
+      mounts.size.should == 17
+      mounts[0].should == { :name => '/', :mounted => :yes }
+      mounts[1].should == { :name => '/devices', :mounted => :yes }
+      mounts[2].should == { :name => '/dev', :mounted => :yes }
+      mounts[3].should == { :name => '/system/contract', :mounted => :yes }
+      mounts[4].should == { :name => '/proc', :mounted => :yes }
+      mounts[5].should == { :name => '/etc/mnttab', :mounted => :yes }
+      mounts[6].should == { :name => '/etc/svc/volatile', :mounted => :yes }
+      mounts[7].should == { :name => '/system/object', :mounted => :yes }
+      mounts[8].should == { :name => '/etc/dfs/sharetab', :mounted => :yes }
+      mounts[9].should == { :name => '/lib/libc.so.1', :mounted => :yes }
+      mounts[10].should == { :name => '/dev/fd', :mounted => :yes }
+      mounts[11].should == { :name => '/tmp', :mounted => :yes }
+      mounts[12].should == { :name => '/var/run', :mounted => :yes }
+      mounts[13].should == { :name => '/export', :mounted => :yes }
+      mounts[14].should == { :name => '/export/home', :mounted => :yes }
+      mounts[15].should == { :name => '/rpool', :mounted => :yes }
+      mounts[16].should == { :name => '/ghost', :mounted => :yes }
     end
 
-    it "should have a filesystem tab" do
-      FileTest.should be_exist(@provider_class.default_target)
+    it "should get name from mountoutput found on Darwin" do
+      Facter.stubs(:value).with(:operatingsystem).returns 'Darwin'
+      @provider.stubs(:mountcmd).returns(File.read(fake_mountoutput))
+      mounts = @provider.mountinstances
+      mounts.size.should == 6
+      mounts[0].should == { :name => '/', :mounted => :yes }
+      mounts[1].should == { :name => '/dev', :mounted => :yes }
+      mounts[2].should == { :name => '/net', :mounted => :yes }
+      mounts[3].should == { :name => '/home', :mounted => :yes }
+      mounts[4].should == { :name => '/usr', :mounted => :yes }
+      mounts[5].should == { :name => '/ghost', :mounted => :yes }
     end
 
-    it "should find the root filesystem" do
-      @provider_class.prefetch("/" => @mount)
-      @mount.provider.property_hash[:ensure].should == :present
+    it "should get name from mountoutput found on Linux" do
+      Facter.stubs(:value).with(:operatingsystem).returns 'Gentoo'
+      @provider.stubs(:mountcmd).returns(File.read(fake_mountoutput))
+      mounts = @provider.mountinstances
+      mounts[0].should == { :name => '/', :mounted => :yes }
+      mounts[1].should == { :name => '/lib64/rc/init.d', :mounted => :yes }
+      mounts[2].should == { :name => '/sys', :mounted => :yes }
+      mounts[3].should == { :name => '/usr/portage', :mounted => :yes }
+      mounts[4].should == { :name => '/ghost', :mounted => :yes }
     end
 
-    it "should determine that the root fs is mounted" do
-      @provider_class.prefetch("/" => @mount)
-      @mount.provider.should be_mounted
+    it "should raise an error if a line is not understandable" do
+      @provider.stubs(:mountcmd).returns("bazinga!")
+      lambda { @provider.mountinstances }.should raise_error Puppet::Error
     end
+
   end
 
-  describe provider_class, " when mounting and unmounting" do
+  describe "when prefetching" do
     include ParsedMountTesting
 
-    it "should call the 'mount' command to mount the filesystem"
+    before :each do
+      @res_ghost = Puppet::Type::Mount.new(:name => '/ghost')    # in no fake fstab
+      @res_mounted = Puppet::Type::Mount.new(:name => '/')       # in every fake fstab
+      @res_unmounted = Puppet::Type::Mount.new(:name => '/boot') # in every fake fstab
+      @res_absent = Puppet::Type::Mount.new(:name => '/absent')  # in no fake fstab
+
+      # Simulate transaction.rb:prefetch
+      @resource_hash = {}
+      [@res_ghost, @res_mounted, @res_unmounted, @res_absent].each do |resource|
+        @resource_hash[resource.name] = resource
+      end
+
+      @provider.stubs(:mountcmd).returns File.read(fake_mountoutput)
+      @provider.stubs(:default_target).returns fake_fstab
+    end
+
+    it "should set :ensure to :unmounted if found in fstab but not mounted" do
+      @provider.prefetch(@resource_hash)
+      @res_unmounted.provider.get(:ensure).should == :unmounted
+    end
+
+    it "should set :ensure to :mounted if found in fstab and mounted" do
+      @provider.prefetch(@resource_hash)
+      @res_ghost.provider.get(:ensure).should == :ghost
+    end
+
+    it "should set :ensure to :ghost if not found in fstab but mounted" do
+      @provider.prefetch(@resource_hash)
+      @res_mounted.provider.get(:ensure).should == :mounted
+    end
 
-    it "should call the 'unmount' command to unmount the filesystem"
+    it "should set :ensure to :absent if not found in fstab and not mounted" do
+      @provider.prefetch(@resource_hash)
+      @res_absent.provider.get(:ensure).should == :absent
+    end
 
-    it "should specify the filesystem when remounting a filesystem"
   end
+
 end
-- 
cgit 


From 2ecf91367c911a87dc5680108222dcc48ecca888 Mon Sep 17 00:00:00 2001
From: Nick Lewis <nick@puppetlabs.com>
Date: Mon, 21 Feb 2011 09:39:19 -0800
Subject: Revert "(#5935) Allow functions to accept negated values"

This reverts commit e3c59df2b246fe5e764272f21b631a5d2f28687f.

This commit is being reverted because the solution is incomplete, and a better
solution is out of scope for this release. A more complete solution will be
implemented in the future.
---
 spec/integration/parser/parser_spec.rb | 13 -------------
 1 file changed, 13 deletions(-)

(limited to 'spec')

diff --git a/spec/integration/parser/parser_spec.rb b/spec/integration/parser/parser_spec.rb
index 000e68dd8..20d87c228 100755
--- a/spec/integration/parser/parser_spec.rb
+++ b/spec/integration/parser/parser_spec.rb
@@ -116,18 +116,5 @@ describe Puppet::Parser::Parser do
         $out = $hash['a']['b']['c']
       }.should parse_with { |v| v.value.is_a?(Puppet::Parser::AST::ASTHash) }
     end
-
-    it "should be able to pass numbers to functions" do
-      %q{
-        my_function(1)
-      }.should parse_as(Puppet::Parser::AST::Function)
-    end
-
-    it "should be able to pass negative numbers to functions" do
-      %q{
-        my_function(-1)
-      }.should parse_as(Puppet::Parser::AST::Function)
-    end
-
   end
 end
-- 
cgit 


From bb31c3d82f58ed192efa1bd8b85958ffa50d1d73 Mon Sep 17 00:00:00 2001
From: Max Martin <max@puppetlabs.com>
Date: Mon, 21 Feb 2011 16:40:10 -0800
Subject: (#6376) Add test case for facts find request

Added test case to ensure indirection name is not changed from "facts"
when making an HTTP GET request.

Reviewed-by:Paul Berry <paul@puppetlabs.com>
---
 spec/unit/network/http/api/v1_spec.rb | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

(limited to 'spec')

diff --git a/spec/unit/network/http/api/v1_spec.rb b/spec/unit/network/http/api/v1_spec.rb
index e7348312b..9a8780c62 100644
--- a/spec/unit/network/http/api/v1_spec.rb
+++ b/spec/unit/network/http/api/v1_spec.rb
@@ -96,7 +96,11 @@ describe Puppet::Network::HTTP::API::V1 do
       @tester.uri2indirection("GET", "/env/facts_search/bar", {}).indirection_name.should == :facts
     end
 
-    it "should change indirection name to 'status' if the http method is a GEt and the indirection name is statuses" do
+    it "should not change indirection name from 'facts' if the http method is a GET and the indirection name is facts" do
+      @tester.uri2indirection("GET", "/env/facts/bar", {}).indirection_name.should == :facts
+    end
+
+    it "should change indirection name to 'status' if the http method is a GET and the indirection name is statuses" do
       @tester.uri2indirection("GET", "/env/statuses/bar", {}).indirection_name.should == :status
     end
 
-- 
cgit 


From de6a2052c2aeda1cd76ba828936a9d6f0ac7e907 Mon Sep 17 00:00:00 2001
From: Daniel Pittman <daniel@rimspace.net>
Date: Tue, 22 Feb 2011 11:18:19 -0800
Subject: (#5552) Clean up subcommand handling inside puppet cert.

We now have a regular, testable mechanism for handling the legacy '--' version
of subcommands, as well as a modern bareword subcommand pattern.  This makes
it sensible to test command handling and avoid regressions.

We identified a few quirks in the command line as part of this process.

Pair-With: Jesse Wolfe <jesse@puppetlabs.com>
Signed-off-by: Daniel Pittman <daniel@puppetlabs.com>
---
 spec/unit/application/cert_spec.rb | 58 +++++++++++++++++++++++++++++---------
 1 file changed, 44 insertions(+), 14 deletions(-)

(limited to 'spec')

diff --git a/spec/unit/application/cert_spec.rb b/spec/unit/application/cert_spec.rb
index 4663fc938..2f57d07a9 100755
--- a/spec/unit/application/cert_spec.rb
+++ b/spec/unit/application/cert_spec.rb
@@ -51,7 +51,7 @@ describe Puppet::Application::Cert do
 
   it "should set cert_mode to :destroy for --clean" do
     @cert_app.handle_clean(0)
-    @cert_app.cert_mode.should == :destroy
+    @cert_app.subcommand.should == :destroy
   end
 
   it "should set all to true for --all" do
@@ -68,7 +68,7 @@ describe Puppet::Application::Cert do
     it "should set cert_mode to #{method} with option --#{method}" do
       @cert_app.send("handle_#{method}".to_sym, nil)
 
-      @cert_app.cert_mode.should == method
+      @cert_app.subcommand.should == method
     end
   end
 
@@ -114,19 +114,19 @@ describe Puppet::Application::Cert do
     end
 
     it "should set the ca_location to :local if the cert_mode is generate" do
-      @cert_app.find_mode('--generate')
+      @cert_app.subcommand = 'generate'
       Puppet::SSL::Host.expects(:ca_location=).with(:local)
       @cert_app.setup
     end
 
     it "should set the ca_location to :local if the cert_mode is destroy" do
-      @cert_app.find_mode('--destroy')
+      @cert_app.subcommand = 'destroy'
       Puppet::SSL::Host.expects(:ca_location=).with(:local)
       @cert_app.setup
     end
 
     it "should set the ca_location to :only if the cert_mode is print" do
-      @cert_app.find_mode('--print')
+      @cert_app.subcommand = 'print'
       Puppet::SSL::Host.expects(:ca_location=).with(:only)
       @cert_app.setup
     end
@@ -171,24 +171,54 @@ describe Puppet::Application::Cert do
       @cert_app.main
     end
 
-    it "should delegate to ca.apply with current set cert_mode" do
-      @cert_app.cert_mode = "currentmode"
+    it "should revoke cert if cert_mode is clean" do
+      @cert_app.subcommand = :destroy
       @cert_app.command_line.stubs(:args).returns(["host"])
 
-      @ca.expects(:apply).with { |cert_mode,to| cert_mode == "currentmode" }
+      @ca.expects(:apply).with { |cert_mode,to| cert_mode == :revoke }
+      @ca.expects(:apply).with { |cert_mode,to| cert_mode == :destroy }
 
       @cert_app.main
     end
+  end
 
-    it "should revoke cert if cert_mode is clean" do
-      @cert_app.cert_mode = :destroy
-      @cert_app.command_line.stubs(:args).returns(["host"])
+  describe "when identifying subcommands" do
+    before :each do
+      @cert_app.all = false
+      @ca = stub_everything 'ca'
+      @cert_app.ca = @ca
+    end
 
-      @ca.expects(:apply).with { |cert_mode,to| cert_mode == :revoke }
-      @ca.expects(:apply).with { |cert_mode,to| cert_mode == :destroy }
+    %w{list revoke generate sign print verify fingerprint}.each do |cmd|
+      short = cmd[0,1]
+      [cmd, "--#{cmd}", "-#{short}"].each do |option|
+        # In our command line '-v' was eaten by 'verbose', so we can't consume
+        # it here; this is a special case from our otherwise standard
+        # processing. --daniel 2011-02-22
+        next if option == "-v"
 
-      @cert_app.main
+        it "should recognise '#{option}'" do
+          args = [option, "fun.example.com"]
+
+          @cert_app.command_line.stubs(:args).returns(args)
+          @cert_app.parse_options
+          @cert_app.subcommand.should == cmd.to_sym
+
+          args.should == ["fun.example.com"]
+        end
+      end
     end
 
+    %w{clean --clean -c}.each do |ugly|
+      it "should recognise the '#{ugly}' option as destroy" do
+        args = [ugly, "fun.example.com"]
+
+        @cert_app.command_line.stubs(:args).returns(args)
+        @cert_app.parse_options
+        @cert_app.subcommand.should == :destroy
+
+        args.should == ["fun.example.com"]
+      end
+    end
   end
 end
-- 
cgit 


From 309b9320feef3e1a9459c7a26d10955b4d6b549c Mon Sep 17 00:00:00 2001
From: Daniel Pittman <daniel@rimspace.net>
Date: Tue, 22 Feb 2011 11:25:03 -0800
Subject: (#5552) Display help when no subcommand is given.

Previously, when the command line was empty we would try and invoke an empty
method; this was less helpful than telling people what they could actually do,
so we adapt our code to do precisely that.

Paired-With: Jesse Wolfe <jesse@puppetlabs.com>
Signed-off-by: Daniel Pittman <daniel@puppetlabs.com>
---
 spec/unit/application/cert_spec.rb | 10 ++++++++++
 1 file changed, 10 insertions(+)

(limited to 'spec')

diff --git a/spec/unit/application/cert_spec.rb b/spec/unit/application/cert_spec.rb
index 2f57d07a9..b3257916b 100755
--- a/spec/unit/application/cert_spec.rb
+++ b/spec/unit/application/cert_spec.rb
@@ -189,6 +189,16 @@ describe Puppet::Application::Cert do
       @cert_app.ca = @ca
     end
 
+    it "should not fail when no command is given" do
+      # Make the help method silent for testing; this is a bit nasty, but we
+      # can't identify a cleaner method.  Help welcome. --daniel 2011-02-22
+      Puppet.features.stubs(:usage?).returns(false)
+      @cert_app.stubs(:puts)
+
+      @cert_app.command_line.stubs(:args).returns([])
+      expect { @cert_app.parse_options }.should raise_error SystemExit
+    end
+
     %w{list revoke generate sign print verify fingerprint}.each do |cmd|
       short = cmd[0,1]
       [cmd, "--#{cmd}", "-#{short}"].each do |option|
-- 
cgit 


From 0e9858f19d9d2e021a9d0aa43b69c6ddee229352 Mon Sep 17 00:00:00 2001
From: Daniel Pittman <daniel@rimspace.net>
Date: Tue, 22 Feb 2011 14:18:57 -0800
Subject: (#6407) Fix spec test hang with Mocha >= 0.9.11 in zlib testing

We had a combination of bad logic, and bad testing, and a nasty behaviour of
Mocha <= 0.9.10 that would result in a false pass for one of our tests.

This not only falsely passed, but hid an infinite loop retrying decompression
on an invalid data stream; it could be triggered by anything that sent an HTTP
request with an invalid compressed body, resulting in a livelock.

Paired-with: Jesse Wolfe <jesse@puppetlabs.com>
Signed-off-by: Daniel Pittman <daniel@puppetlabs.com>
---
 spec/unit/network/http/compression_spec.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
 mode change 100644 => 100755 spec/unit/network/http/compression_spec.rb

(limited to 'spec')

diff --git a/spec/unit/network/http/compression_spec.rb b/spec/unit/network/http/compression_spec.rb
old mode 100644
new mode 100755
index c5bbbb064..3828ec59c
--- a/spec/unit/network/http/compression_spec.rb
+++ b/spec/unit/network/http/compression_spec.rb
@@ -178,7 +178,7 @@ describe "http compression" do
       end
 
       it "should raise the error the second time" do
-        @inflater.expects(:inflate).raises(Zlib::DataError.new("not a zlib stream"))
+        @inflater.stubs(:inflate).raises(Zlib::DataError.new("not a zlib stream"))
         Zlib::Inflate.expects(:new).with.returns(@inflater)
         lambda { @adapter.uncompress("chunk") }.should raise_error
       end
-- 
cgit 


From 23eb77d999acb73021547c5ef86adf609e202605 Mon Sep 17 00:00:00 2001
From: Jesse Wolfe <jes5199@gmail.com>
Date: Fri, 25 Feb 2011 11:45:38 -0800
Subject: (#6322) --noop should not suppress error codes

The noop option has been suppressing exit statuses. This is
counterintuitive, as per discussion at http://projects.puppetlabs.com/issues/6322

This patch causes noop runs to return the same exit codes as real runs.

Reviewed-By: Daniel Pittman <daniel@puppetlabs.com>
---
 spec/unit/application/agent_spec.rb |  4 ++--
 spec/unit/application/apply_spec.rb | 16 ++++++++++++++++
 2 files changed, 18 insertions(+), 2 deletions(-)

(limited to 'spec')

diff --git a/spec/unit/application/agent_spec.rb b/spec/unit/application/agent_spec.rb
index 9fc7879c9..8f498d4ba 100755
--- a/spec/unit/application/agent_spec.rb
+++ b/spec/unit/application/agent_spec.rb
@@ -526,11 +526,11 @@ describe Puppet::Application::Agent do
           @puppetd.onetime
         end
 
-        it "should always exit with 0 if --noop" do
+        it "should exit with the report's computer exit status, even if --noop is set." do
           Puppet.stubs(:[]).with(:noop).returns(true)
           report = stub 'report', :exit_status => 666
           @agent.stubs(:run).returns(report)
-          @puppetd.expects(:exit).with(0)
+          @puppetd.expects(:exit).with(666)
 
           @puppetd.onetime
         end
diff --git a/spec/unit/application/apply_spec.rb b/spec/unit/application/apply_spec.rb
index ceba4a333..d4f39abe0 100755
--- a/spec/unit/application/apply_spec.rb
+++ b/spec/unit/application/apply_spec.rb
@@ -166,6 +166,13 @@ describe Puppet::Application::Apply do
         @apply.expects(:exit).with(1)
         @apply.parseonly
       end
+
+      it "should exit with exit code 1 if error, even if --noop is set" do
+        Puppet[:noop] = true
+        @collection.stubs(:perform_initial_import).raises(Puppet::ParseError)
+        @apply.expects(:exit).with(1)
+        @apply.parseonly
+      end
     end
 
     describe "the main command" do
@@ -327,6 +334,15 @@ describe Puppet::Application::Apply do
           @apply.main
         end
 
+        it "should exit with report's computed exit status, even if --noop is set" do
+          Puppet.stubs(:[]).with(:noop).returns(true)
+          @apply.options.stubs(:[]).with(:detailed_exitcodes).returns(true)
+          Puppet::Transaction::Report.any_instance.stubs(:exit_status).returns(666)
+          @apply.expects(:exit).with(666)
+
+          @apply.main
+        end
+
         it "should always exit with 0 if option is disabled" do
           Puppet.stubs(:[]).with(:noop).returns(false)
           @apply.options.stubs(:[]).with(:detailed_exitcodes).returns(false)
-- 
cgit 


From ac2262d071cc2c9841843354585980696c689ca3 Mon Sep 17 00:00:00 2001
From: Jesse Wolfe <jes5199@gmail.com>
Date: Fri, 25 Feb 2011 13:45:10 -0800
Subject: (#3999) Allow disabling of default SELinux context detection for
 files

In most cases on a system with SELinux, it is preferred to use
the SELinux matchpathcon call to determine the default context that
a file should have to make sure that files Puppet modifies are
labeled with the correct SELinux security context.

In the event that you wanted to override some or all of the default
context, you can use the SELinux attributes Puppet provides to do
that. If left unspecified the defaults will apply if matchpathcon has
defaults.

This patch adds a new selinux_ignore_defaults parameter which
will cause Puppet to assume no defaults, allowing the file's
SELinux label to be left unmodified, if desired.

Originally-by: Sean Millichamp <sean@bruenor.org>
Signed-off-by: Jesse Wolfe <jes5199@gmail.com>
---
 spec/unit/type/file/selinux_spec.rb | 5 +++++
 1 file changed, 5 insertions(+)

(limited to 'spec')

diff --git a/spec/unit/type/file/selinux_spec.rb b/spec/unit/type/file/selinux_spec.rb
index 043471dec..a2444acd9 100644
--- a/spec/unit/type/file/selinux_spec.rb
+++ b/spec/unit/type/file/selinux_spec.rb
@@ -66,6 +66,11 @@ Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f
       @sel.default.must == expectedresult
     end
 
+    it "should return nil for defaults if selinux_ignore_defaults is true" do
+      @resource[:selinux_ignore_defaults] = :true
+      @sel.default.must be_nil
+    end
+
     it "should be able to set a new context" do
       stat = stub 'stat', :ftype => "foo"
       @sel.should = %w{newone}
-- 
cgit 


From 23a510a321e47a98768dc47f95cfa0bd8c1a314c Mon Sep 17 00:00:00 2001
From: Paul Berry <paul@puppetlabs.com>
Date: Fri, 25 Feb 2011 14:56:58 -0800
Subject: (#4914) Improved stubbing in mount/parsed_spec tests.

A few of the spec tests were attempting to stub
Puppet::Type::Mount#default_target so that it pointed to a temporary
file rather than /etc/fstab, but they were creating the stub after the
first call to default_target, so both /etc/fstab and the temporary
file were being read.  This caused errors when running spec tests on
platforms where /etc/fstab is unreadable by non-privileged users.

Fixed the problem by moving the stub declaration earlier in the test.
---
 spec/unit/provider/mount/parsed_spec.rb | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

(limited to 'spec')

diff --git a/spec/unit/provider/mount/parsed_spec.rb b/spec/unit/provider/mount/parsed_spec.rb
index 2a305b905..4d654fa72 100755
--- a/spec/unit/provider/mount/parsed_spec.rb
+++ b/spec/unit/provider/mount/parsed_spec.rb
@@ -220,6 +220,11 @@ FSTAB
     include ParsedMountTesting
 
     before :each do
+      # Note: we have to stub default_target before creating resources
+      # because it is used by Puppet::Type::Mount.new to populate the
+      # :target property.
+      @provider.stubs(:default_target).returns fake_fstab
+
       @res_ghost = Puppet::Type::Mount.new(:name => '/ghost')    # in no fake fstab
       @res_mounted = Puppet::Type::Mount.new(:name => '/')       # in every fake fstab
       @res_unmounted = Puppet::Type::Mount.new(:name => '/boot') # in every fake fstab
@@ -232,7 +237,6 @@ FSTAB
       end
 
       @provider.stubs(:mountcmd).returns File.read(fake_mountoutput)
-      @provider.stubs(:default_target).returns fake_fstab
     end
 
     it "should set :ensure to :unmounted if found in fstab but not mounted" do
-- 
cgit 


From a949a83c4f100be0254fadcb915f418f73705861 Mon Sep 17 00:00:00 2001
From: Paul Berry <paul@puppetlabs.com>
Date: Fri, 25 Feb 2011 15:14:26 -0800
Subject: Revert "(#6309) Ensure the correct device is mounted when managing
 mounts"

This reverts commit 6cb365a887d47606bdfae0ff540038b0c49b7451, which
fixed bug #6309 but introduced bug #6411.  In addition, it conflicts
with a significant patch to the mount provider that addresses #4914.

After merging in the fix for #4914 I will determine whether bug #6309
still exists, and if so work on an improved fix for it.
---
 .../unit/provider/mount/mount-output.darwin.txt    |   5 -
 .../unit/provider/mount/mount-output.hp-ux.txt     |  16 --
 .../unit/provider/mount/mount-output.other.txt     |  14 --
 .../unit/provider/mount/mount-output.solaris.txt   |  16 --
 spec/unit/provider/mount/parsed_spec.rb            |   4 +-
 spec/unit/provider/mount_spec.rb                   | 185 +++++++--------------
 spec/unit/type/mount_spec.rb                       |  56 +++++--
 7 files changed, 105 insertions(+), 191 deletions(-)
 delete mode 100644 spec/fixtures/unit/provider/mount/mount-output.darwin.txt
 delete mode 100644 spec/fixtures/unit/provider/mount/mount-output.hp-ux.txt
 delete mode 100644 spec/fixtures/unit/provider/mount/mount-output.other.txt
 delete mode 100644 spec/fixtures/unit/provider/mount/mount-output.solaris.txt

(limited to 'spec')

diff --git a/spec/fixtures/unit/provider/mount/mount-output.darwin.txt b/spec/fixtures/unit/provider/mount/mount-output.darwin.txt
deleted file mode 100644
index fbb9d9832..000000000
--- a/spec/fixtures/unit/provider/mount/mount-output.darwin.txt
+++ /dev/null
@@ -1,5 +0,0 @@
-/dev/disk0s2 on / (hfs, local, journaled)
-devfs on /dev (devfs, local, nobrowse)
-map -hosts on /net (autofs, nosuid, automounted, nobrowse)
-map auto_home on /home (autofs, automounted, nobrowse)
-/dev/disk0s3 on /usr (hfs, local, journaled)
diff --git a/spec/fixtures/unit/provider/mount/mount-output.hp-ux.txt b/spec/fixtures/unit/provider/mount/mount-output.hp-ux.txt
deleted file mode 100644
index 477926138..000000000
--- a/spec/fixtures/unit/provider/mount/mount-output.hp-ux.txt
+++ /dev/null
@@ -1,16 +0,0 @@
-/ on rpool/ROOT/opensolaris read/write/setuid/devices/dev=2d90002 on Wed Dec 31 16:00:00 1969
-/devices on /devices read/write/setuid/devices/dev=4a00000 on Thu Feb 17 14:34:02 2011
-/dev on /dev read/write/setuid/devices/dev=4a40000 on Thu Feb 17 14:34:02 2011
-/system/contract on ctfs read/write/setuid/devices/dev=4ac0001 on Thu Feb 17 14:34:02 2011
-/proc on proc read/write/setuid/devices/dev=4b00000 on Thu Feb 17 14:34:02 2011
-/etc/mnttab on mnttab read/write/setuid/devices/dev=4b40001 on Thu Feb 17 14:34:02 2011
-/etc/svc/volatile on swap read/write/setuid/devices/xattr/dev=4b80001 on Thu Feb 17 14:34:02 2011
-/system/object on objfs read/write/setuid/devices/dev=4bc0001 on Thu Feb 17 14:34:02 2011
-/etc/dfs/sharetab on sharefs read/write/setuid/devices/dev=4c00001 on Thu Feb 17 14:34:02 2011
-/lib/libc.so.1 on /usr/lib/libc/libc_hwcap1.so.1 read/write/setuid/devices/dev=2d90002 on Thu Feb 17 14:34:14 2011
-/dev/fd on fd read/write/setuid/devices/dev=4d00001 on Thu Feb 17 14:34:18 2011
-/tmp on swap read/write/setuid/devices/xattr/dev=4b80002 on Thu Feb 17 14:34:19 2011
-/var/run on swap read/write/setuid/devices/xattr/dev=4b80003 on Thu Feb 17 14:34:19 2011
-/export on rpool/export read/write/setuid/devices/nonbmand/exec/xattr/atime/dev=2d90006 on Thu Feb 17 14:37:48 2011
-/export/home on rpool/export/home read/write/setuid/devices/nonbmand/exec/xattr/atime/dev=2d90007 on Thu Feb 17 14:37:48 2011
-/rpool on rpool read/write/setuid/devices/nonbmand/exec/xattr/atime/dev=2d90009 on Thu Feb 17 14:37:48 2011
diff --git a/spec/fixtures/unit/provider/mount/mount-output.other.txt b/spec/fixtures/unit/provider/mount/mount-output.other.txt
deleted file mode 100644
index 0e4dff0c5..000000000
--- a/spec/fixtures/unit/provider/mount/mount-output.other.txt
+++ /dev/null
@@ -1,14 +0,0 @@
-/dev/sda1 on / type ext4 (rw,errors=remount-ro,commit=0)
-proc on /proc type proc (rw,noexec,nosuid,nodev)
-none on /sys type sysfs (rw,noexec,nosuid,nodev)
-fusectl on /sys/fs/fuse/connections type fusectl (rw)
-none on /sys/kernel/debug type debugfs (rw)
-none on /sys/kernel/security type securityfs (rw)
-none on /dev type devtmpfs (rw,mode=0755)
-none on /dev/pts type devpts (rw,noexec,nosuid,gid=5,mode=0620)
-none on /dev/shm type tmpfs (rw,nosuid,nodev)
-none on /var/run type tmpfs (rw,nosuid,mode=0755)
-none on /var/lock type tmpfs (rw,noexec,nosuid,nodev)
-none on /proc/fs/vmblock/mountPoint type vmblock (rw)
-binfmt_misc on /proc/sys/fs/binfmt_misc type binfmt_misc (rw,noexec,nosuid,nodev)
-/dev/sda2 on /usr type ext4 (rw,errors=remount-ro,commit=0)
diff --git a/spec/fixtures/unit/provider/mount/mount-output.solaris.txt b/spec/fixtures/unit/provider/mount/mount-output.solaris.txt
deleted file mode 100644
index 477926138..000000000
--- a/spec/fixtures/unit/provider/mount/mount-output.solaris.txt
+++ /dev/null
@@ -1,16 +0,0 @@
-/ on rpool/ROOT/opensolaris read/write/setuid/devices/dev=2d90002 on Wed Dec 31 16:00:00 1969
-/devices on /devices read/write/setuid/devices/dev=4a00000 on Thu Feb 17 14:34:02 2011
-/dev on /dev read/write/setuid/devices/dev=4a40000 on Thu Feb 17 14:34:02 2011
-/system/contract on ctfs read/write/setuid/devices/dev=4ac0001 on Thu Feb 17 14:34:02 2011
-/proc on proc read/write/setuid/devices/dev=4b00000 on Thu Feb 17 14:34:02 2011
-/etc/mnttab on mnttab read/write/setuid/devices/dev=4b40001 on Thu Feb 17 14:34:02 2011
-/etc/svc/volatile on swap read/write/setuid/devices/xattr/dev=4b80001 on Thu Feb 17 14:34:02 2011
-/system/object on objfs read/write/setuid/devices/dev=4bc0001 on Thu Feb 17 14:34:02 2011
-/etc/dfs/sharetab on sharefs read/write/setuid/devices/dev=4c00001 on Thu Feb 17 14:34:02 2011
-/lib/libc.so.1 on /usr/lib/libc/libc_hwcap1.so.1 read/write/setuid/devices/dev=2d90002 on Thu Feb 17 14:34:14 2011
-/dev/fd on fd read/write/setuid/devices/dev=4d00001 on Thu Feb 17 14:34:18 2011
-/tmp on swap read/write/setuid/devices/xattr/dev=4b80002 on Thu Feb 17 14:34:19 2011
-/var/run on swap read/write/setuid/devices/xattr/dev=4b80003 on Thu Feb 17 14:34:19 2011
-/export on rpool/export read/write/setuid/devices/nonbmand/exec/xattr/atime/dev=2d90006 on Thu Feb 17 14:37:48 2011
-/export/home on rpool/export/home read/write/setuid/devices/nonbmand/exec/xattr/atime/dev=2d90007 on Thu Feb 17 14:37:48 2011
-/rpool on rpool read/write/setuid/devices/nonbmand/exec/xattr/atime/dev=2d90009 on Thu Feb 17 14:37:48 2011
diff --git a/spec/unit/provider/mount/parsed_spec.rb b/spec/unit/provider/mount/parsed_spec.rb
index 069d9495a..b4c2249fd 100755
--- a/spec/unit/provider/mount/parsed_spec.rb
+++ b/spec/unit/provider/mount/parsed_spec.rb
@@ -130,7 +130,7 @@ describe provider_class do
       mount.stubs(:mountcmd) # just so we don't actually try to mount anything
 
       mount.expects(:flush)
-      mount.mount!
+      mount.mount
     end
   end
 
@@ -176,7 +176,7 @@ describe provider_class do
 
     it "should determine that the root fs is mounted" do
       @provider_class.prefetch("/" => @mount)
-      @mount.provider.should be_anything_mounted
+      @mount.provider.should be_mounted
     end
   end
 end
diff --git a/spec/unit/provider/mount_spec.rb b/spec/unit/provider/mount_spec.rb
index 1f2501765..f567a4a40 100755
--- a/spec/unit/provider/mount_spec.rb
+++ b/spec/unit/provider/mount_spec.rb
@@ -2,30 +2,28 @@
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
-require 'puppet_spec/files'
 require 'puppet/provider/mount'
 
 describe Puppet::Provider::Mount do
-  include PuppetSpec::Files
-
   before :each do
+    @mounter = Object.new
+    @mounter.extend(Puppet::Provider::Mount)
+
     @name = "/"
 
-    @resource = Puppet::Type.type(:mount).new(
-      :name => '/',
-      :device => '/dev/sda1',
-      :target => tmpfile("mount_provider")
-    )
+    @resource = stub 'resource'
+    @resource.stubs(:[]).with(:name).returns(@name)
 
-    @mounter = Puppet::Type.type(:mount).defaultprovider().new(@resource)
+    @mounter.stubs(:resource).returns(@resource)
   end
 
-  describe "when calling mount!" do
+  describe Puppet::Provider::Mount, " when mounting" do
+
     it "should use the 'mountcmd' method to mount" do
       @mounter.stubs(:options).returns(nil)
       @mounter.expects(:mountcmd)
 
-      @mounter.mount!
+      @mounter.mount
     end
 
     it "should flush before mounting if a flush method exists" do
@@ -34,169 +32,114 @@ describe Puppet::Provider::Mount do
       @mounter.stubs(:mountcmd)
       @mounter.stubs(:options).returns(nil)
 
-      @mounter.mount!
+      @mounter.mount
     end
 
     it "should add the options following '-o' if they exist and are not set to :absent" do
       @mounter.stubs(:options).returns("ro")
       @mounter.expects(:mountcmd).with { |*ary| ary[0] == "-o" and ary[1] == "ro" }
 
-      @mounter.mount!
+      @mounter.mount
     end
 
     it "should specify the filesystem name to the mount command" do
       @mounter.stubs(:options).returns(nil)
       @mounter.expects(:mountcmd).with { |*ary| ary[-1] == @name }
 
-      @mounter.mount!
+      @mounter.mount
     end
   end
 
-  describe "when remounting" do
+  describe Puppet::Provider::Mount, " when remounting" do
+
     it "should use '-o remount' if the resource specifies it supports remounting" do
       @mounter.stubs(:info)
-      @resource[:remounts] = true
+      @resource.stubs(:[]).with(:remounts).returns(:true)
       @mounter.expects(:mountcmd).with("-o", "remount", @name)
       @mounter.remount
     end
 
     it "should unmount and mount if the resource does not specify it supports remounting" do
       @mounter.stubs(:info)
-      @resource[:remounts] = false
+      @resource.stubs(:[]).with(:remounts).returns(false)
       @mounter.expects(:unmount)
       @mounter.expects(:mount)
       @mounter.remount
     end
 
     it "should log that it is remounting" do
-      @resource[:remounts] = true
+      @resource.stubs(:[]).with(:remounts).returns(:true)
       @mounter.stubs(:mountcmd)
       @mounter.expects(:info).with("Remounting")
       @mounter.remount
     end
   end
 
-  describe "when unmounting" do
+  describe Puppet::Provider::Mount, " when unmounting" do
+
     it "should call the :umount command with the resource name" do
       @mounter.expects(:umount).with(@name)
       @mounter.unmount
     end
   end
 
-  %w{Darwin Solaris HP-UX AIX Other}.each do |platform|
-    describe "on #{platform}" do
-      before :each do
-        case platform
-        when 'Darwin'
-          mount_fixture = 'mount-output.darwin.txt'
-          @mount_device = '/dev/disk0s3'
-          @mount_point = '/usr'
-        when 'Solaris'
-          mount_fixture = 'mount-output.solaris.txt'
-          @mount_device = 'swap'
-          @mount_point = '/tmp'
-        when 'HP-UX'
-          mount_fixture = 'mount-output.hp-ux.txt'
-          @mount_device = 'swap'
-          @mount_point = '/tmp'
-        when 'AIX'
-          mount_fixture = 'mount-output.aix.txt'
-          @mount_device = '/dev/hd2'
-          @mount_point = '/usr'
-        when 'Other'
-          mount_fixture = 'mount-output.other.txt'
-          @mount_device = '/dev/sda2'
-          @mount_point = '/usr'
-        end
-        @mount_data = File.read(File.join(File.dirname(__FILE__), '..', '..', 'fixtures', 'unit', 'provider', 'mount', mount_fixture))
-        Facter.stubs(:value).with("operatingsystem").returns(platform)
-      end
-
-      describe "when the correct thing is mounted" do
-        before :each do
-          @mounter.expects(:mountcmd).returns(@mount_data)
-          @resource.stubs(:[]).with(:name).returns(@mount_point)
-          @resource.stubs(:[]).with(:device).returns(@mount_device)
-        end
-
-        it "should say anything_mounted?" do
-          @mounter.should be_anything_mounted
-        end
-
-        it "should say correctly_mounted?" do
-          @mounter.should be_correctly_mounted
-        end
-      end
-
-      describe "when the wrong thing is mounted" do
-        before :each do
-          @mounter.expects(:mountcmd).returns(@mount_data)
-          @resource.stubs(:[]).with(:name).returns(@mount_point)
-          @resource.stubs(:[]).with(:device).returns('/dev/bogus/thing')
-        end
-
-        it "should say anything_mounted?" do
-          @mounter.should be_anything_mounted
-        end
-
-        it "should not say correctly_mounted?" do
-          @mounter.should_not be_correctly_mounted
-        end
-      end
-
-      describe "when nothing is mounted" do
-        before :each do
-          @mounter.expects(:mountcmd).returns(@mount_data)
-          @resource.stubs(:[]).with(:name).returns('/bogus/location')
-          @resource.stubs(:[]).with(:device).returns(@mount_device)
-        end
-
-        it "should not say anything_mounted?" do
-          @mounter.should_not be_anything_mounted
-        end
-
-        it "should not say correctly_mounted?" do
-          @mounter.should_not be_correctly_mounted
-        end
-      end
+  describe Puppet::Provider::Mount, " when determining if it is mounted" do
+
+    it "should parse the results of running the mount command with no arguments" do
+      Facter.stubs(:value).returns("whatever")
+      @mounter.expects(:mountcmd).returns("")
+
+      @mounter.mounted?
     end
-  end
 
-  describe "when mounting a device" do
-    it "should not mount! or unmount anything when the correct device is mounted" do
-      @mounter.stubs(:correctly_mounted?).returns(true)
+    it "should match ' on /private/var/automount<name>' if the operating system is Darwin" do
+      Facter.stubs(:value).with("operatingsystem").returns("Darwin")
+      @mounter.expects(:mountcmd).returns("/dev/whatever on /private/var/automount/\ndevfs on /dev")
 
-      @mounter.expects(:anything_mounted?).never
-      @mounter.expects(:create).once
-      @mounter.expects(:mount!).never
-      @mounter.expects(:unmount).never
-      FileUtils.expects(:mkdir_p).never
+      @mounter.should be_mounted
+    end
 
-      @mounter.mount
+    it "should match ' on <name>' if the operating system is Darwin" do
+      Facter.stubs(:value).with("operatingsystem").returns("Darwin")
+      @mounter.expects(:mountcmd).returns("/dev/disk03 on / (local, journaled)\ndevfs on /dev")
+
+      @mounter.should be_mounted
     end
 
-    it "should mount the device when nothing is mounted at the desired point" do
-      @mounter.stubs(:correctly_mounted?).returns(false)
-      @mounter.stubs(:anything_mounted?).returns(false)
+    it "should match '^<name> on' if the operating system is Solaris" do
+      Facter.stubs(:value).with("operatingsystem").returns("Solaris")
+      @mounter.expects(:mountcmd).returns("/ on /dev/dsk/whatever\n/var on /dev/dsk/other")
 
-      @mounter.expects(:create).once
-      @mounter.expects(:mount!).once
-      @mounter.expects(:unmount).never
-      FileUtils.expects(:mkdir_p).never
+      @mounter.should be_mounted
+    end
 
-      @mounter.mount
+    it "should match '^<name> on' if the operating system is HP-UX" do
+      Facter.stubs(:value).with("operatingsystem").returns("HP-UX")
+      @mounter.expects(:mountcmd).returns("/ on /dev/dsk/whatever\n/var on /dev/dsk/other")
+
+      @mounter.should be_mounted
     end
 
-    it "should unmount the incorrect device and mount the correct device" do
-      @mounter.stubs(:correctly_mounted?).returns(false)
-      @mounter.stubs(:anything_mounted?).returns(true)
+    it "should match mounted devices if the operating system is AIX" do
+      Facter.stubs(:value).with("operatingsystem").returns("AIX")
+      mount_data = File.read(File.join(File.dirname(__FILE__), '..', '..', 'fixtures', 'unit', 'provider', 'mount', 'mount-output.aix.txt'))
+      @mounter.expects(:mountcmd).returns(mount_data)
 
-      @mounter.expects(:create).once
-      @mounter.expects(:mount!).once
-      @mounter.expects(:unmount).once
-      FileUtils.expects(:mkdir_p).with(@name).returns(true)
+      @mounter.should be_mounted
+    end
 
-      @mounter.mount
+    it "should match ' on <name>' if the operating system is not Darwin, Solaris, or HP-UX" do
+      Facter.stubs(:value).with("operatingsystem").returns("Debian")
+      @mounter.expects(:mountcmd).returns("/dev/dsk/whatever on / and stuff\n/dev/other/disk on /var and stuff")
+
+      @mounter.should be_mounted
+    end
+
+    it "should not be considered mounted if it did not match the mount output" do
+      Facter.stubs(:value).with("operatingsystem").returns("Debian")
+      @mounter.expects(:mountcmd).returns("/dev/dsk/whatever on /something/else and stuff\n/dev/other/disk on /var and stuff")
+
+      @mounter.should_not be_mounted
     end
   end
 end
diff --git a/spec/unit/type/mount_spec.rb b/spec/unit/type/mount_spec.rb
index c6d2b5ba0..0d74042e3 100755
--- a/spec/unit/type/mount_spec.rb
+++ b/spec/unit/type/mount_spec.rb
@@ -74,7 +74,8 @@ describe Puppet::Type.type(:mount)::Ensure do
     end
   end
 
-  describe "when retrieving its current state" do
+  describe Puppet::Type.type(:mount)::Ensure, "when retrieving its current state" do
+
     it "should return the provider's value if it is :absent" do
       @provider.expects(:ensure).returns(:absent)
       @ensure.retrieve.should == :absent
@@ -82,27 +83,28 @@ describe Puppet::Type.type(:mount)::Ensure do
 
     it "should return :mounted if the provider indicates it is mounted and the value is not :absent" do
       @provider.expects(:ensure).returns(:present)
-      @provider.expects(:correctly_mounted?).returns(true)
+      @provider.expects(:mounted?).returns(true)
       @ensure.retrieve.should == :mounted
     end
 
     it "should return :unmounted if the provider indicates it is not mounted and the value is not :absent" do
       @provider.expects(:ensure).returns(:present)
-      @provider.expects(:correctly_mounted?).returns(false)
+      @provider.expects(:mounted?).returns(false)
       @ensure.retrieve.should == :unmounted
     end
   end
 
-  describe "when changing the host" do
+  describe Puppet::Type.type(:mount)::Ensure, "when changing the host" do
+
     it "should destroy itself if it should be absent" do
-      @provider.stubs(:anything_mounted?).returns(false)
+      @provider.stubs(:mounted?).returns(false)
       @provider.expects(:destroy)
       @ensure.should = :absent
       @ensure.sync
     end
 
     it "should unmount itself before destroying if it is mounted and should be absent" do
-      @provider.expects(:anything_mounted?).returns(true)
+      @provider.expects(:mounted?).returns(true)
       @provider.expects(:unmount)
       @provider.expects(:destroy)
       @ensure.should = :absent
@@ -111,9 +113,9 @@ describe Puppet::Type.type(:mount)::Ensure do
 
     it "should create itself if it is absent and should be defined" do
       @provider.stubs(:ensure).returns(:absent)
-      @provider.stubs(:anything_mounted?).returns(true)
+      @provider.stubs(:mounted?).returns(true)
 
-      @provider.stubs(:anything_mounted?).returns(false)
+      @provider.stubs(:mounted?).returns(false)
       @provider.expects(:create)
       @ensure.should = :defined
       @ensure.sync
@@ -121,7 +123,7 @@ describe Puppet::Type.type(:mount)::Ensure do
 
     it "should not unmount itself if it is mounted and should be defined" do
       @provider.stubs(:ensure).returns(:mounted)
-      @provider.stubs(:anything_mounted?).returns(true)
+      @provider.stubs(:mounted?).returns(true)
 
       @provider.stubs(:create)
       @provider.expects(:mount).never
@@ -132,7 +134,7 @@ describe Puppet::Type.type(:mount)::Ensure do
 
     it "should not mount itself if it is unmounted and should be defined" do
       @provider.stubs(:ensure).returns(:unmounted)
-      @provider.stubs(:anything_mounted?).returns(false)
+      @provider.stubs(:mounted?).returns(false)
 
       @ensure.stubs(:syncothers)
       @provider.stubs(:create)
@@ -144,7 +146,7 @@ describe Puppet::Type.type(:mount)::Ensure do
 
     it "should unmount itself if it is mounted and should be unmounted" do
       @provider.stubs(:ensure).returns(:present)
-      @provider.stubs(:anything_mounted?).returns(true)
+      @provider.stubs(:mounted?).returns(true)
 
       @ensure.stubs(:syncothers)
       @provider.expects(:unmount)
@@ -152,14 +154,34 @@ describe Puppet::Type.type(:mount)::Ensure do
       @ensure.sync
     end
 
-    it "should ask the provider to mount itself" do
+    it "should create and mount itself if it does not exist and should be mounted" do
+      @provider.stubs(:ensure).returns(:absent)
+      @provider.stubs(:mounted?).returns(false)
+      @provider.expects(:create)
+      @ensure.stubs(:syncothers)
+      @provider.expects(:mount)
+      @ensure.should = :mounted
+      @ensure.sync
+    end
+
+    it "should mount itself if it is present and should be mounted" do
       @provider.stubs(:ensure).returns(:present)
+      @provider.stubs(:mounted?).returns(false)
       @ensure.stubs(:syncothers)
       @provider.expects(:mount)
       @ensure.should = :mounted
       @ensure.sync
     end
 
+    it "should create but not mount itself if it is absent and mounted and should be mounted" do
+      @provider.stubs(:ensure).returns(:absent)
+      @provider.stubs(:mounted?).returns(true)
+      @ensure.stubs(:syncothers)
+      @provider.expects(:create)
+      @ensure.should = :mounted
+      @ensure.sync
+    end
+
     it "should be insync if it is mounted and should be defined" do
       @ensure.should = :defined
       @ensure.safe_insync?(:mounted).should == true
@@ -181,16 +203,17 @@ describe Puppet::Type.type(:mount)::Ensure do
     end
   end
 
-  describe "when responding to events" do
+  describe Puppet::Type.type(:mount), "when responding to events" do
+
     it "should remount if it is currently mounted" do
-      @provider.expects(:anything_mounted?).returns(true)
+      @provider.expects(:mounted?).returns(true)
       @provider.expects(:remount)
 
       @mount.refresh
     end
 
     it "should not remount if it is not currently mounted" do
-      @provider.expects(:anything_mounted?).returns(false)
+      @provider.expects(:mounted?).returns(false)
       @provider.expects(:remount).never
 
       @mount.refresh
@@ -218,8 +241,7 @@ describe Puppet::Type.type(:mount), "when modifying an existing mount entry" do
       @mount[param] = value
     end
 
-    @mount.provider.stubs(:anything_mounted?).returns true
-    @mount.provider.stubs(:correctly_mounted?).returns true
+    @mount.provider.stubs(:mounted?).returns true
 
     # stub this to not try to create state.yaml
     Puppet::Util::Storage.stubs(:store)
-- 
cgit 


From 743e03930758d17ed35fc6b73f7c2c68d8212137 Mon Sep 17 00:00:00 2001
From: Nick Lewis <nick@puppetlabs.com>
Date: Mon, 28 Feb 2011 13:40:18 -0800
Subject: (#4922) Don't truncate remotely-sourced files on 404

We were 'handling' 404's on remote file content retrieval by returning nil
rather than raising an exception. This caused no content to be written to the
temporary file, but still appeared successful, so the destination file was
overwritten, instead of preserved.  Now we just handle 404 like any other
error.

Note that the root cause of these 404s seems to have been #4319, which has been
fixed. However, in the event we do happen to get a 404 here, it's better not to
have code to specifically handle it incorrectly.

Paired-With: Max Martin
Reviewed-By: Matt Robinson
---
 spec/unit/type/file/content_spec.rb | 175 ++++++++----------------------------
 1 file changed, 38 insertions(+), 137 deletions(-)

(limited to 'spec')

diff --git a/spec/unit/type/file/content_spec.rb b/spec/unit/type/file/content_spec.rb
index 9178c94bf..7d23399cf 100755
--- a/spec/unit/type/file/content_spec.rb
+++ b/spec/unit/type/file/content_spec.rb
@@ -4,15 +4,14 @@ Dir.chdir(File.dirname(__FILE__)) { (s = lambda { |f| File.exist?(f) ? require(f
 
 content = Puppet::Type.type(:file).attrclass(:content)
 describe content do
+  include PuppetSpec::Files
   before do
-    @resource = Puppet::Type.type(:file).new :path => "/foo/bar"
+    @filename = tmpfile('testfile')
+    @resource = Puppet::Type.type(:file).new :path => @filename
+    File.open(@filename, 'w') {|f| f.write "initial file content"}
     content.stubs(:standalone?).returns(false)
   end
 
-  it "should be a subclass of Property" do
-    content.superclass.must == Puppet::Property
-  end
-
   describe "when determining the checksum type" do
     it "should use the type specified in the source checksum if a source is set" do
       @resource[:source] = "/foo"
@@ -249,10 +248,10 @@ describe content do
   describe "when writing" do
     before do
       @content = content.new(:resource => @resource)
-      @fh = stub_everything
     end
 
     it "should attempt to read from the filebucket if no actual content nor source exists" do
+      @fh = File.open(@filename, 'w')
       @content.should = "{md5}foo"
       @content.resource.bucket.class.any_instance.stubs(:getfile).returns "foo"
       @content.write(@fh)
@@ -302,166 +301,68 @@ describe content do
 
     describe "from local source" do
       before(:each) do
-        @content.stubs(:actual_content).returns(nil)
-        @source = stub_everything 'source', :local? => true, :full_path => "/path/to/source"
-        @resource.stubs(:parameter).with(:source).returns @source
-
-        @sum = stub_everything 'sum'
-        @resource.stubs(:parameter).with(:checksum).returns(@sum)
-
-        @digest = stub_everything 'digest'
-        @sum.stubs(:sum_stream).yields(@digest)
-
-        @file = stub_everything 'file'
-        File.stubs(:open).yields(@file)
-        @file.stubs(:read).with(8192).returns("chunk1").then.returns("chunk2").then.returns(nil)
-      end
-
-      it "should open the local file" do
-        File.expects(:open).with("/path/to/source", "r")
-        @content.write(@fh)
-      end
+        @resource = Puppet::Type.type(:file).new :path => @filename, :backup => false
+        @sourcename = tmpfile('source')
+        @source_content = "source file content"*10000
+        @sourcefile = File.open(@sourcename, 'w') {|f| f.write @source_content}
 
-      it "should read the local file by chunks" do
-        @file.expects(:read).with(8192).returns("chunk1").then.returns(nil)
-        @content.write(@fh)
+        @content = @resource.newattr(:content)
+        @source = @resource.newattr(:source)
+        @source.stubs(:metadata).returns stub_everything('metadata', :source => @sourcename, :ftype => 'file')
       end
 
-      it "should write each chunk to the file" do
-        @fh.expects(:print).with("chunk1").then.with("chunk2")
-        @content.write(@fh)
-      end
-
-      it "should pass each chunk to the current sum stream" do
-        @digest.expects(:<<).with("chunk1").then.with("chunk2")
-        @content.write(@fh)
+      it "should copy content from the source to the file" do
+        @resource.write(@source)
+        File.read(@filename).should == @source_content
       end
 
       it "should return the checksum computed" do
-        @sum.stubs(:sum_stream).yields(@digest).returns("checksum")
-        @content.write(@fh).should == "checksum"
+        File.open(@filename, 'w') do |file|
+          @content.write(file).should == "{md5}#{Digest::MD5.hexdigest(@source_content)}"
+        end
       end
     end
 
     describe "from remote source" do
       before(:each) do
-        @response = stub_everything 'mock response', :code => "404"
+        @resource = Puppet::Type.type(:file).new :path => @filename, :backup => false
+        @response = stub_everything 'response', :code => "200"
+        @source_content = "source file content"*10000
+        @response.stubs(:read_body).multiple_yields(*(["source file content"]*10000))
+
         @conn = stub_everything 'connection'
         @conn.stubs(:request_get).yields(@response)
         Puppet::Network::HttpPool.stubs(:http_instance).returns @conn
 
-        @content.stubs(:actual_content).returns(nil)
-        @source = stub_everything 'source', :local? => false, :full_path => "/path/to/source", :server => "server", :port => 1234
-        @resource.stubs(:parameter).with(:source).returns @source
-
-        @sum = stub_everything 'sum'
-        @resource.stubs(:parameter).with(:checksum).returns(@sum)
-
-        @digest = stub_everything 'digest'
-        @sum.stubs(:sum_stream).yields(@digest)
-      end
-
-      it "should open a network connection to source server and port" do
-        Puppet::Network::HttpPool.expects(:http_instance).with("server", 1234).returns @conn
-        @content.write(@fh)
-      end
-
-      it "should send the correct indirection uri" do
-        @conn.expects(:request_get).with { |uri,headers| uri == "/production/file_content/path/to/source" }.yields(@response)
-        @content.write(@fh)
+        @content = @resource.newattr(:content)
+        @sourcename = "puppet:///test/foo"
+        @source = @resource.newattr(:source)
+        @source.stubs(:metadata).returns stub_everything('metadata', :source => @sourcename, :ftype => 'file')
       end
 
-      it "should return nil if source is not found" do
-        @response.expects(:code).returns("404")
-        @content.write(@fh).should == nil
+      it "should write the contents to the file" do
+        @resource.write(@source)
+        File.read(@filename).should == @source_content
       end
 
       it "should not write anything if source is not found" do
-        @response.expects(:code).returns("404")
-        @fh.expects(:print).never
-        @content.write(@fh).should == nil
+        @response.stubs(:code).returns("404")
+        lambda {@resource.write(@source)}.should raise_error(Net::HTTPError) { |e| e.message =~ /404/ }
+        File.read(@filename).should == "initial file content"
       end
 
       it "should raise an HTTP error in case of server error" do
-        @response.expects(:code).returns("500")
-        lambda { @content.write(@fh) }.should raise_error
-      end
-
-      it "should write content by chunks" do
-        @response.expects(:code).returns("200")
-        @response.expects(:read_body).multiple_yields("chunk1","chunk2")
-        @fh.expects(:print).with("chunk1").then.with("chunk2")
-        @content.write(@fh)
-      end
-
-      it "should pass each chunk to the current sum stream" do
-        @response.expects(:code).returns("200")
-        @response.expects(:read_body).multiple_yields("chunk1","chunk2")
-        @digest.expects(:<<).with("chunk1").then.with("chunk2")
-        @content.write(@fh)
+        @response.stubs(:code).returns("500")
+        lambda { @content.write(@fh) }.should raise_error { |e| e.message.include? @source_content }
       end
 
       it "should return the checksum computed" do
-        @response.expects(:code).returns("200")
-        @response.expects(:read_body).multiple_yields("chunk1","chunk2")
-        @sum.expects(:sum_stream).yields(@digest).returns("checksum")
-        @content.write(@fh).should == "checksum"
-      end
-
-      it "should get the current accept encoding header value" do
-        @content.expects(:add_accept_encoding)
-        @content.write(@fh)
-      end
-
-      it "should uncompress body on error" do
-        @response.expects(:code).returns("500")
-        @response.expects(:body).returns("compressed body")
-        @content.expects(:uncompress_body).with(@response).returns("uncompressed")
-        lambda { @content.write(@fh) }.should raise_error { |e| e.message =~ /uncompressed/ }
-      end
-
-      it "should uncompress chunk by chunk" do
-        uncompressor = stub_everything 'uncompressor'
-        @content.expects(:uncompress).with(@response).yields(uncompressor)
-        @response.expects(:code).returns("200")
-        @response.expects(:read_body).multiple_yields("chunk1","chunk2")
-
-        uncompressor.expects(:uncompress).with("chunk1").then.with("chunk2")
-        @content.write(@fh)
-      end
-
-      it "should write uncompressed chunks to the file" do
-        uncompressor = stub_everything 'uncompressor'
-        @content.expects(:uncompress).with(@response).yields(uncompressor)
-        @response.expects(:code).returns("200")
-        @response.expects(:read_body).multiple_yields("chunk1","chunk2")
-
-        uncompressor.expects(:uncompress).with("chunk1").returns("uncompressed1")
-        uncompressor.expects(:uncompress).with("chunk2").returns("uncompressed2")
-
-        @fh.expects(:print).with("uncompressed1")
-        @fh.expects(:print).with("uncompressed2")
-
-        @content.write(@fh)
-      end
-
-      it "should pass each uncompressed chunk to the current sum stream" do
-        uncompressor = stub_everything 'uncompressor'
-        @content.expects(:uncompress).with(@response).yields(uncompressor)
-        @response.expects(:code).returns("200")
-        @response.expects(:read_body).multiple_yields("chunk1","chunk2")
-
-        uncompressor.expects(:uncompress).with("chunk1").returns("uncompressed1")
-        uncompressor.expects(:uncompress).with("chunk2").returns("uncompressed2")
-
-        @digest.expects(:<<).with("uncompressed1").then.with("uncompressed2")
-        @content.write(@fh)
+        File.open(@filename, 'w') do |file|
+          @content.write(file).should == "{md5}#{Digest::MD5.hexdigest(@source_content)}"
+        end
       end
     end
 
-    describe "from a filebucket" do
-    end
-
     # These are testing the implementation rather than the desired behaviour; while that bites, there are a whole
     # pile of other methods in the File type that depend on intimate details of this implementation and vice-versa.
     # If these blow up, you are gonna have to review the callers to make sure they don't explode! --daniel 2011-02-01
-- 
cgit 


From 422399b47764e29055974ff5bad5dfcb982a8b74 Mon Sep 17 00:00:00 2001
From: Matt Robinson <matt@puppetlabs.com>
Date: Mon, 28 Feb 2011 16:55:18 -0800
Subject: (#5466) Write specs for output of puppet resource

Reviewed-by: Nick Lewis <nick@puppetlabs.com>
---
 spec/unit/resource_spec.rb | 30 +++++++++++++++++-------------
 1 file changed, 17 insertions(+), 13 deletions(-)

(limited to 'spec')

diff --git a/spec/unit/resource_spec.rb b/spec/unit/resource_spec.rb
index ff31b2492..eaa3d5519 100755
--- a/spec/unit/resource_spec.rb
+++ b/spec/unit/resource_spec.rb
@@ -99,11 +99,11 @@ describe Puppet::Resource do
   end
 
   it 'should fail if strict is set and type does not exist' do
-    lambda { Puppet::Resource.new('foo', 'title', {:strict=>true}) }.should raise_error(ArgumentError, 'Invalid resource type foo') 
+    lambda { Puppet::Resource.new('foo', 'title', {:strict=>true}) }.should raise_error(ArgumentError, 'Invalid resource type foo')
   end
 
   it 'should fail if strict is set and class does not exist' do
-    lambda { Puppet::Resource.new('Class', 'foo', {:strict=>true}) }.should raise_error(ArgumentError, 'Could not find declared class foo') 
+    lambda { Puppet::Resource.new('Class', 'foo', {:strict=>true}) }.should raise_error(ArgumentError, 'Could not find declared class foo')
   end
 
   it "should fail if the title is a hash and the type is not a valid resource reference string" do
@@ -486,19 +486,23 @@ describe Puppet::Resource do
 
   describe "when converting to puppet code" do
     before do
-      @resource = Puppet::Resource.new("one::two", "/my/file", :parameters => {:noop => true, :foo => %w{one two}})
-    end
-
-    it "should print the type and title" do
-      @resource.to_manifest.should be_include("one::two { '/my/file':\n")
-    end
-
-    it "should print each parameter, with the value single-quoted" do
-      @resource.to_manifest.should be_include("    noop => 'true'")
+      @resource = Puppet::Resource.new("one::two", "/my/file",
+        :parameters => {
+          :noop => true,
+          :foo => %w{one two},
+          :ensure => 'present',
+        }
+      )
     end
 
-    it "should print array values appropriately" do
-      @resource.to_manifest.should be_include("    foo => ['one','two']")
+    it "should align, sort and add trailing commas to attributes with ensure first" do
+      @resource.to_manifest.should == <<-HEREDOC.gsub(/^\s{8}/, '').gsub(/\n$/, '')
+        one::two { '/my/file':
+          ensure => 'present',
+          foo    => ['one', 'two'],
+          noop   => 'true',
+        }
+      HEREDOC
     end
   end
 
-- 
cgit 


From b907ba3156cdc273e220a1fc00deb500843d19e5 Mon Sep 17 00:00:00 2001
From: Matt Robinson <matt@puppetlabs.com>
Date: Tue, 1 Mar 2011 16:04:36 -0800
Subject: (#6541) Fix content with checksum truncation bug

The patch for #6107 fd73874147a1aaa3a047f904a0bc1ae67780a2e4 introduced
a bug when content was an invalid checksum.  Rather than error the
checksum was invalid, it would overwrite the file with empty string,
essentially truncating it.

The problem with #6107 is that when I wrote it, I didn't realize that
the content parameter was munged to be nil when it was a checksum, and
then chunking method special cased nil content to mean you should check
the filebucket.  #6107 intended to fix the case where content REALLY WAS
nil, and handle that by returning an empty string.

This patch fixes it so that we check to see if we really passed in a
checksum when chunking, and only then going to the filebucket.

Surprisingly it is possible to have a content checksum should value set
from source, so we have to be careful not to assume the use of the
filebucket whenever there's a checksum.  The following manifest produces
this situation:

  file { "/tmp/mydir" :
    source  => '/tmp/sourcedir',
    recurse => true,
  }

I've said it before, and sure I'll say it again, but long term the file
provider really needs a refactor.  I'll write some acceptance tests for
file behavior right after committing this so that the refactoring will
be easier.

Reviewed-by: Daniel Pittman <daniel@puppetlabs.com>
---
 spec/unit/type/file/content_spec.rb | 23 ++++++++++++++++++++++-
 1 file changed, 22 insertions(+), 1 deletion(-)

(limited to 'spec')

diff --git a/spec/unit/type/file/content_spec.rb b/spec/unit/type/file/content_spec.rb
index 7d23399cf..bd2b2adaf 100755
--- a/spec/unit/type/file/content_spec.rb
+++ b/spec/unit/type/file/content_spec.rb
@@ -375,17 +375,38 @@ describe content do
         @content.each_chunk_from('i_am_a_string') { |chunk| chunk.should == 'i_am_a_string' }
       end
 
+      # The following manifest is a case where source and content.should are both set
+      # file { "/tmp/mydir" :
+      #   source  => '/tmp/sourcedir',
+      #   recurse => true,
+      # }
+      it "when content checksum comes from source" do
+        source_param = Puppet::Type.type(:file).attrclass(:source)
+        source = source_param.new(:resource => @resource)
+        @content.should = "{md5}123abcd"
+
+        @content.expects(:chunk_file_from_source).returns('from_source')
+        @content.each_chunk_from(source) { |chunk| chunk.should == 'from_source' }
+      end
+
       it "when no content, source, but ensure present" do
         @resource[:ensure] = :present
         @content.each_chunk_from(nil) { |chunk| chunk.should == '' }
       end
 
+      # you might do this if you were just auditing
       it "when no content, source, but ensure file" do
         @resource[:ensure] = :file
         @content.each_chunk_from(nil) { |chunk| chunk.should == '' }
       end
 
-      it "when no content or source" do
+      it "when source_or_content is nil and content not a checksum" do
+        @content.each_chunk_from(nil) { |chunk| chunk.should == '' }
+      end
+
+      # the content is munged so that if it's a checksum nil gets passed in
+      it "when content is a checksum it should try to read from filebucket" do
+        @content.should = "{md5}123abcd"
         @content.expects(:read_file_from_filebucket).once.returns('im_a_filebucket')
         @content.each_chunk_from(nil) { |chunk| chunk.should == 'im_a_filebucket' }
       end
-- 
cgit 


From 4e29f439189e0a40364724f50971c83652463085 Mon Sep 17 00:00:00 2001
From: Matt Robinson <matt@puppetlabs.com>
Date: Tue, 1 Mar 2011 21:45:07 -0800
Subject: (#6541) maint: whitespace cleanup on the file integration spec

---
 spec/integration/type/file_spec.rb | 61 ++++++++++++++++++++------------------
 1 file changed, 32 insertions(+), 29 deletions(-)

(limited to 'spec')

diff --git a/spec/integration/type/file_spec.rb b/spec/integration/type/file_spec.rb
index 4b91e5ef9..31f4adee6 100755
--- a/spec/integration/type/file_spec.rb
+++ b/spec/integration/type/file_spec.rb
@@ -173,7 +173,12 @@ describe Puppet::Type.type(:file) do
     it "should be able to recurse over a nonexistent file" do
       @path = tmpfile("file_integration_tests")
 
-      @file = Puppet::Type::File.new(:name => @path, :mode => 0644, :recurse => true, :backup => false)
+      @file = Puppet::Type::File.new(
+        :name    => @path,
+        :mode    => 0644,
+        :recurse => true,
+        :backup  => false
+      )
 
       @catalog = Puppet::Resource::Catalog.new
       @catalog.add_resource @file
@@ -186,7 +191,12 @@ describe Puppet::Type.type(:file) do
 
       build_path(@path)
 
-      @file = Puppet::Type::File.new(:name => @path, :mode => 0644, :recurse => true, :backup => false)
+      @file = Puppet::Type::File.new(
+        :name    => @path,
+        :mode    => 0644,
+        :recurse => true,
+        :backup  => false
+      )
 
       @catalog = Puppet::Resource::Catalog.new
       @catalog.add_resource @file
@@ -393,10 +403,8 @@ describe Puppet::Type.type(:file) do
     dest = tmpfile("files_with_content")
 
 
-          file = Puppet::Type.type(:file).new(
-                
-      :name => dest,
-        
+    file = Puppet::Type.type(:file).new(
+      :name    => dest,
       :content => "this is some content, yo"
     )
 
@@ -411,11 +419,9 @@ describe Puppet::Type.type(:file) do
     dest = tmpfile("files_with_content")
 
 
-          file = Puppet::Type.type(:file).new(
-                
-      :name => dest,
-      :ensure => "file",
-        
+    file = Puppet::Type.type(:file).new(
+      :name    => dest,
+      :ensure  => "file",
       :content => "this is some content, yo"
     )
 
@@ -433,12 +439,10 @@ describe Puppet::Type.type(:file) do
     File.open(dest, "w") { |f| f.puts "boo" }
 
 
-          file = Puppet::Type.type(:file).new(
-                
-      :name => dest,
+    file = Puppet::Type.type(:file).new(
+      :name   => dest,
       :ensure => :absent,
       :source => source,
-        
       :backup => false
     )
 
@@ -465,24 +469,23 @@ describe Puppet::Type.type(:file) do
       File.open(@purgee, "w") { |f| f.puts "footest" }
 
 
-            @lfobj = Puppet::Type.newfile(
-                
-        :title => "localfile",
-        :path => @localfile,
+      @lfobj = Puppet::Type.newfile(
+        :title   => "localfile",
+        :path    => @localfile,
         :content => "rahtest\n",
-        :ensure => :file,
-        
-        :backup => false
+        :ensure  => :file,
+        :backup  => false
       )
 
 
-            @destobj = Puppet::Type.newfile(
-        :title => "destdir", :path => @destdir,
-                    :source => @sourcedir,
-                    :backup => false,
-                    :purge => true,
-        
-                    :recurse => true)
+      @destobj = Puppet::Type.newfile(
+        :title   => "destdir",
+        :path    => @destdir,
+        :source  => @sourcedir,
+        :backup  => false,
+        :purge   => true,
+        :recurse => true
+      )
 
       @catalog = Puppet::Resource::Catalog.new
       @catalog.add_resource @lfobj, @destobj
-- 
cgit 


From c3baa2899d88fadd4bbe94e008015e33f98132c7 Mon Sep 17 00:00:00 2001
From: Nick Lewis <nick@puppetlabs.com>
Date: Thu, 3 Mar 2011 14:12:44 -0800
Subject: (#6338) Remove inventory indirection, and move to facts indirection

The inventory indirection was just providing the search method for facts.
Because the route is now facts_search instead of inventory, it can just be
implemented as the search method for facts.

Reviewed-By: Daniel Pittman
---
 spec/unit/indirector/facts/yaml_spec.rb     | 214 +++++++++++++++++++++++++++
 spec/unit/indirector/inventory/yaml_spec.rb | 221 ----------------------------
 2 files changed, 214 insertions(+), 221 deletions(-)
 delete mode 100644 spec/unit/indirector/inventory/yaml_spec.rb

(limited to 'spec')

diff --git a/spec/unit/indirector/facts/yaml_spec.rb b/spec/unit/indirector/facts/yaml_spec.rb
index 37a1bcae0..c625c8ee3 100755
--- a/spec/unit/indirector/facts/yaml_spec.rb
+++ b/spec/unit/indirector/facts/yaml_spec.rb
@@ -23,4 +23,218 @@ describe Puppet::Node::Facts::Yaml do
   it "should have its name set to :yaml" do
     Puppet::Node::Facts::Yaml.name.should == :yaml
   end
+
+  describe "#search" do
+    def assert_search_matches(matching, nonmatching, query)
+      request = Puppet::Indirector::Request.new(:inventory, :search, nil, query)
+
+      Dir.stubs(:glob).returns(matching.keys + nonmatching.keys)
+      [matching, nonmatching].each do |examples|
+        examples.each do |key, value|
+          YAML.stubs(:load_file).with(key).returns value
+        end
+      end
+      Puppet::Node::Facts::Yaml.new.search(request).should =~ matching.values.map {|facts| facts.name}
+    end
+
+    it "should return node names that match the search query options" do
+      assert_search_matches({
+          '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386", 'processor_count' => '4'),
+          '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "i386", 'processor_count' => '4', 'randomfact' => 'foo')
+        },
+        {
+          "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '4'),
+          "/path/to/nonmatching1.yaml" => Puppet::Node::Facts.new("nonmatchingnode1", "architecture" => "powerpc", 'processor_count' => '5'),
+          "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '5'),
+          "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3",                              'processor_count' => '4'),
+        },
+        {'facts.architecture' => 'i386', 'facts.processor_count' => '4'}
+      )
+    end
+
+    it "should return empty array when no nodes match the search query options" do
+      assert_search_matches({}, {
+          "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '10'),
+          "/path/to/nonmatching1.yaml" => Puppet::Node::Facts.new("nonmatchingnode1", "architecture" => "powerpc", 'processor_count' => '5'),
+          "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '5'),
+          "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3",                              'processor_count' => '4'),
+        },
+        {'facts.processor_count.lt' => '4', 'facts.processor_count.gt' => '4'}
+      )
+    end
+
+
+    it "should return node names that match the search query options with the greater than operator" do
+      assert_search_matches({
+          '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '5'),
+          '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '10', 'randomfact' => 'foo')
+        },
+        {
+          "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '4'),
+          "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '3'),
+          "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                       ),
+        },
+        {'facts.processor_count.gt' => '4'}
+      )
+    end
+
+    it "should return node names that match the search query options with the less than operator" do
+      assert_search_matches({
+          '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '5'),
+          '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '30', 'randomfact' => 'foo')
+        },
+        {
+          "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '50' ),
+          "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '100'),
+          "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                         ),
+        },
+        {'facts.processor_count.lt' => '50'}
+      )
+    end
+
+    it "should return node names that match the search query options with the less than or equal to operator" do
+      assert_search_matches({
+          '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '5'),
+          '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '50', 'randomfact' => 'foo')
+        },
+        {
+          "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '100' ),
+          "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '5000'),
+          "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                          ),
+        },
+        {'facts.processor_count.le' => '50'}
+      )
+    end
+
+    it "should return node names that match the search query options with the greater than or equal to operator" do
+      assert_search_matches({
+          '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '100'),
+          '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '50', 'randomfact' => 'foo')
+        },
+        {
+          "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '40'),
+          "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '9' ),
+          "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                        ),
+        },
+        {'facts.processor_count.ge' => '50'}
+      )
+    end
+
+    it "should return node names that match the search query options with the not equal operator" do
+      assert_search_matches({
+          '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => 'arm'                           ),
+          '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => 'powerpc', 'randomfact' => 'foo')
+        },
+        {
+          "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "i386"                           ),
+          "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386", 'processor_count' => '9' ),
+          "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                     ),
+        },
+        {'facts.architecture.ne' => 'i386'}
+      )
+    end
+
+    def apply_timestamp(facts, timestamp)
+      facts.timestamp = timestamp
+      facts
+    end
+
+    it "should be able to query based on meta.timestamp.gt" do
+      assert_search_matches({
+          '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+          '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+        },
+        {
+          '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+          '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+          '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+        },
+        {'meta.timestamp.gt' => '2010-10-15'}
+      )
+    end
+
+    it "should be able to query based on meta.timestamp.le" do
+      assert_search_matches({
+          '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+          '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+          '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+        },
+        {
+          '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+          '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+        },
+        {'meta.timestamp.le' => '2010-10-15'}
+      )
+    end
+
+    it "should be able to query based on meta.timestamp.lt" do
+      assert_search_matches({
+          '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+          '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+        },
+        {
+          '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+          '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+          '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+        },
+        {'meta.timestamp.lt' => '2010-10-15'}
+      )
+    end
+
+    it "should be able to query based on meta.timestamp.ge" do
+      assert_search_matches({
+          '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+          '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+          '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+        },
+        {
+          '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+          '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+        },
+        {'meta.timestamp.ge' => '2010-10-15'}
+      )
+    end
+
+    it "should be able to query based on meta.timestamp.eq" do
+      assert_search_matches({
+          '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+        },
+        {
+          '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+          '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+          '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+          '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+        },
+        {'meta.timestamp.eq' => '2010-10-15'}
+      )
+    end
+
+    it "should be able to query based on meta.timestamp" do
+      assert_search_matches({
+          '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+        },
+        {
+          '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+          '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+          '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+          '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+        },
+        {'meta.timestamp' => '2010-10-15'}
+      )
+    end
+
+    it "should be able to query based on meta.timestamp.ne" do
+      assert_search_matches({
+          '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
+          '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
+          '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
+          '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
+        },
+        {
+          '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
+        },
+        {'meta.timestamp.ne' => '2010-10-15'}
+      )
+    end
+  end
 end
diff --git a/spec/unit/indirector/inventory/yaml_spec.rb b/spec/unit/indirector/inventory/yaml_spec.rb
deleted file mode 100644
index 9f0c54353..000000000
--- a/spec/unit/indirector/inventory/yaml_spec.rb
+++ /dev/null
@@ -1,221 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-require 'puppet/node/inventory'
-require 'puppet/indirector/inventory/yaml'
-require 'puppet/indirector/request'
-
-describe Puppet::Node::Inventory::Yaml do
-  def assert_search_matches(matching, nonmatching, query)
-    request = Puppet::Indirector::Request.new(:inventory, :search, nil, query)
-
-    Dir.stubs(:glob).returns(matching.keys + nonmatching.keys)
-    [matching, nonmatching].each do |examples|
-      examples.each do |key, value|
-        YAML.stubs(:load_file).with(key).returns value
-      end
-    end
-    Puppet::Node::Inventory::Yaml.new.search(request).should =~ matching.values.map {|facts| facts.name}
-  end
-
-  it "should return node names that match the search query options" do
-    assert_search_matches({
-        '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386", 'processor_count' => '4'),
-        '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "i386", 'processor_count' => '4', 'randomfact' => 'foo')
-      },
-      {
-        "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '4'),
-        "/path/to/nonmatching1.yaml" => Puppet::Node::Facts.new("nonmatchingnode1", "architecture" => "powerpc", 'processor_count' => '5'),
-        "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '5'),
-        "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3",                              'processor_count' => '4'),
-      },
-      {'facts.architecture' => 'i386', 'facts.processor_count' => '4'}
-    )
-  end
-
-  it "should return empty array when no nodes match the search query options" do
-    assert_search_matches({}, {
-        "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '10'),
-        "/path/to/nonmatching1.yaml" => Puppet::Node::Facts.new("nonmatchingnode1", "architecture" => "powerpc", 'processor_count' => '5'),
-        "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '5'),
-        "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3",                              'processor_count' => '4'),
-      },
-      {'facts.processor_count.lt' => '4', 'facts.processor_count.gt' => '4'}
-    )
-  end
-
-
-  it "should return node names that match the search query options with the greater than operator" do
-    assert_search_matches({
-        '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '5'),
-        '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '10', 'randomfact' => 'foo')
-      },
-      {
-        "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '4'),
-        "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '3'),
-        "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                       ),
-      },
-      {'facts.processor_count.gt' => '4'}
-    )
-  end
-
-  it "should return node names that match the search query options with the less than operator" do
-    assert_search_matches({
-        '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '5'),
-        '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '30', 'randomfact' => 'foo')
-      },
-      {
-        "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '50' ),
-        "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '100'),
-        "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                         ),
-      },
-      {'facts.processor_count.lt' => '50'}
-    )
-  end
-
-  it "should return node names that match the search query options with the less than or equal to operator" do
-    assert_search_matches({
-        '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '5'),
-        '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '50', 'randomfact' => 'foo')
-      },
-      {
-        "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '100' ),
-        "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '5000'),
-        "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                          ),
-      },
-      {'facts.processor_count.le' => '50'}
-    )
-  end
-
-  it "should return node names that match the search query options with the greater than or equal to operator" do
-    assert_search_matches({
-        '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '100'),
-        '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => "powerpc", 'processor_count' => '50', 'randomfact' => 'foo')
-      },
-      {
-        "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "powerpc", 'processor_count' => '40'),
-        "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386",    'processor_count' => '9' ),
-        "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                        ),
-      },
-      {'facts.processor_count.ge' => '50'}
-    )
-  end
-
-  it "should return node names that match the search query options with the not equal operator" do
-    assert_search_matches({
-        '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => 'arm'                           ),
-        '/path/to/matching1.yaml' => Puppet::Node::Facts.new("matchingnode1", "architecture" => 'powerpc', 'randomfact' => 'foo')
-      },
-      {
-        "/path/to/nonmatching.yaml"  => Puppet::Node::Facts.new("nonmatchingnode",  "architecture" => "i386"                           ),
-        "/path/to/nonmatching2.yaml" => Puppet::Node::Facts.new("nonmatchingnode2", "architecture" => "i386", 'processor_count' => '9' ),
-        "/path/to/nonmatching3.yaml" => Puppet::Node::Facts.new("nonmatchingnode3"                                                     ),
-      },
-      {'facts.architecture.ne' => 'i386'}
-    )
-  end
-
-  def apply_timestamp(facts, timestamp)
-    facts.timestamp = timestamp
-    facts
-  end
-
-  it "should be able to query based on meta.timestamp.gt" do
-    assert_search_matches({
-        '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
-        '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
-      },
-      {
-        '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
-        '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
-        '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
-      },
-      {'meta.timestamp.gt' => '2010-10-15'}
-    )
-  end
-
-  it "should be able to query based on meta.timestamp.le" do
-    assert_search_matches({
-        '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
-        '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
-        '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
-      },
-      {
-        '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
-        '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
-      },
-      {'meta.timestamp.le' => '2010-10-15'}
-    )
-  end
-
-  it "should be able to query based on meta.timestamp.lt" do
-    assert_search_matches({
-        '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
-        '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
-      },
-      {
-        '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
-        '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
-        '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
-      },
-      {'meta.timestamp.lt' => '2010-10-15'}
-    )
-  end
-
-  it "should be able to query based on meta.timestamp.ge" do
-    assert_search_matches({
-        '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
-        '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
-        '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
-      },
-      {
-        '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
-        '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
-      },
-      {'meta.timestamp.ge' => '2010-10-15'}
-    )
-  end
-
-  it "should be able to query based on meta.timestamp.eq" do
-    assert_search_matches({
-        '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
-      },
-      {
-        '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
-        '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
-        '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
-        '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
-      },
-      {'meta.timestamp.eq' => '2010-10-15'}
-    )
-  end
-
-  it "should be able to query based on meta.timestamp" do
-    assert_search_matches({
-        '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
-      },
-      {
-        '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
-        '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
-        '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
-        '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
-      },
-      {'meta.timestamp' => '2010-10-15'}
-    )
-  end
-
-  it "should be able to query based on meta.timestamp.ne" do
-    assert_search_matches({
-        '/path/to/2010-11-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-01", {}), Time.parse("2010-11-01")),
-        '/path/to/2010-11-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-11-10", {}), Time.parse("2010-11-10")),
-        '/path/to/2010-10-01.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-01", {}), Time.parse("2010-10-01")),
-        '/path/to/2010-10-10.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-10", {}), Time.parse("2010-10-10")),
-      },
-      {
-        '/path/to/2010-10-15.yaml' => apply_timestamp(Puppet::Node::Facts.new("2010-10-15", {}), Time.parse("2010-10-15")),
-      },
-      {'meta.timestamp.ne' => '2010-10-15'}
-    )
-  end
-end
-- 
cgit 


From 8bd80a99a259e6409a9ac0a8a60325f94b5c5e9d Mon Sep 17 00:00:00 2001
From: Nick Lewis <nick@puppetlabs.com>
Date: Thu, 28 Oct 2010 12:49:19 -0700
Subject: (#5148) Add support for PSON to facts

Previously, facts could be fetched via the REST API in PSON, but came
back as the to_s representation of a Ruby object, rather than as
proper PSON data. This patch adds to_pson and from_pson to facts, so
they can be properly used with PSON.
---
 spec/unit/node/facts_spec.rb | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

(limited to 'spec')

diff --git a/spec/unit/node/facts_spec.rb b/spec/unit/node/facts_spec.rb
index 394db7913..19049e9bf 100755
--- a/spec/unit/node/facts_spec.rb
+++ b/spec/unit/node/facts_spec.rb
@@ -109,5 +109,29 @@ describe Puppet::Node::Facts, "when indirecting" do
       facts = Puppet::Node::Facts.new("me", "one" => "two", "three" => "four")
       facts.values[:_timestamp].should be_instance_of(Time)
     end
+
+    describe "using pson" do
+      before :each do
+        @timestamp = Time.parse("Thu Oct 28 11:16:31 -0700 2010")
+        @expiration = Time.parse("Thu Oct 28 11:21:31 -0700 2010")
+      end
+
+      it "should accept properly formatted pson" do
+        pson = %Q({"name": "foo", "expiration": "#{@expiration}", "timestamp": "#{@timestamp}", "values": {"a": "1", "b": "2", "c": "3"}})
+        format = Puppet::Network::FormatHandler.format('pson')
+        facts = format.intern(Puppet::Node::Facts,pson)
+        facts.name.should == 'foo'
+        facts.expiration.should == @expiration
+        facts.values.should == {'a' => '1', 'b' => '2', 'c' => '3', :_timestamp => @timestamp}
+      end
+
+      it "should generate properly formatted pson" do
+        Time.stubs(:now).returns(@timestamp)
+        facts = Puppet::Node::Facts.new("foo", {'a' => 1, 'b' => 2, 'c' => 3})
+        facts.expiration = @expiration
+        pson = PSON.parse(facts.to_pson)
+        pson.should == {"name"=>"foo", "timestamp"=>"Thu Oct 28 11:16:31 -0700 2010", "expiration"=>"Thu Oct 28 11:21:31 -0700 2010", "values"=>{"a"=>1, "b"=>2, "c"=>3}}
+      end
+    end
   end
 end
-- 
cgit 


From e3aec14c2ede8ea9b6b1c1684755c715b9923295 Mon Sep 17 00:00:00 2001
From: Nick Lewis <nick@puppetlabs.com>
Date: Thu, 28 Oct 2010 14:30:02 -0700
Subject: (#5148) Fix failing spec due to timezone

Time.parse(...) will yield a string in the local timezone. So when
this spec was run in a non -0700 timezone, it was failing, because
it was comparing a string in local time to a string in -0700. This
fixes it to compare to the local string representation of the time.
---
 spec/unit/node/facts_spec.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'spec')

diff --git a/spec/unit/node/facts_spec.rb b/spec/unit/node/facts_spec.rb
index 19049e9bf..cb2aa3dc7 100755
--- a/spec/unit/node/facts_spec.rb
+++ b/spec/unit/node/facts_spec.rb
@@ -130,7 +130,7 @@ describe Puppet::Node::Facts, "when indirecting" do
         facts = Puppet::Node::Facts.new("foo", {'a' => 1, 'b' => 2, 'c' => 3})
         facts.expiration = @expiration
         pson = PSON.parse(facts.to_pson)
-        pson.should == {"name"=>"foo", "timestamp"=>"Thu Oct 28 11:16:31 -0700 2010", "expiration"=>"Thu Oct 28 11:21:31 -0700 2010", "values"=>{"a"=>1, "b"=>2, "c"=>3}}
+        pson.should == {"name"=>"foo", "timestamp"=>@timestamp.to_s, "expiration"=>@expiration.to_s, "values"=>{"a"=>1, "b"=>2, "c"=>3}}
       end
     end
   end
-- 
cgit 


From 455a89129a6860215d8e79972f720eaa7564e625 Mon Sep 17 00:00:00 2001
From: Valdis Victor Vitayaudom <valdis.vitayaudom@gmail.com>
Date: Sat, 5 Mar 2011 13:36:02 -0800
Subject: (#5794) create reports directory when creating host specific
 directory

---
 spec/unit/reports/store_spec.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'spec')

diff --git a/spec/unit/reports/store_spec.rb b/spec/unit/reports/store_spec.rb
index 1acb5badd..9d9042386 100644
--- a/spec/unit/reports/store_spec.rb
+++ b/spec/unit/reports/store_spec.rb
@@ -11,7 +11,7 @@ describe processor do
   describe "#process" do
     include PuppetSpec::Files
     before :each do
-      Puppet[:reportdir] = tmpdir('reports')
+      Puppet[:reportdir] = tmpdir('reports') << '/reports' 
       @report = YAML.load_file(File.join(PuppetSpec::FIXTURE_DIR, 'yaml/report2.6.x.yaml')).extend processor
     end
 
-- 
cgit 


From 23d1c0346a609369b457da876714c6671fcf3d44 Mon Sep 17 00:00:00 2001
From: Paul Berry <paul@puppetlabs.com>
Date: Thu, 24 Feb 2011 12:43:45 -0800
Subject: Maint: Added the ability to replace the behavior of
 Puppet::Util.execute with an arbitrary code block for ease in spec testing.

Reviewed-by: Max Martin <max@puppetlabs.com>
---
 spec/spec_helper.rb                   |  1 +
 spec/unit/util/execution_stub_spec.rb | 35 +++++++++++++++++++++++++++++++++++
 2 files changed, 36 insertions(+)
 create mode 100644 spec/unit/util/execution_stub_spec.rb

(limited to 'spec')

diff --git a/spec/spec_helper.rb b/spec/spec_helper.rb
index a374fb008..ae4edb2d9 100644
--- a/spec/spec_helper.rb
+++ b/spec/spec_helper.rb
@@ -34,6 +34,7 @@ RSpec.configure do |config|
     Puppet.settings.clear
     Puppet::Node::Environment.clear
     Puppet::Util::Storage.clear
+    Puppet::Util::ExecutionStub.reset
 
     if defined?($tmpfiles)
       $tmpfiles.each do |file|
diff --git a/spec/unit/util/execution_stub_spec.rb b/spec/unit/util/execution_stub_spec.rb
new file mode 100644
index 000000000..14cf9c67a
--- /dev/null
+++ b/spec/unit/util/execution_stub_spec.rb
@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Puppet::Util::ExecutionStub do
+  it "should use the provided stub code when 'set' is called" do
+    Puppet::Util::ExecutionStub.set do |command, options|
+      command.should == ['/bin/foo', 'bar']
+      "stub output"
+    end
+    Puppet::Util::ExecutionStub.current_value.should_not == nil
+    Puppet::Util.execute(['/bin/foo', 'bar']).should == "stub output"
+  end
+
+  it "should automatically restore normal execution at the conclusion of each spec test" do
+    # Note: this test relies on the previous test creating a stub.
+    Puppet::Util::ExecutionStub.current_value.should == nil
+  end
+
+  it "should restore normal execution after 'reset' is called" do
+    true_command = Puppet::Util.which('true') # Note: "true" exists at different paths in different OSes
+    stub_call_count = 0
+    Puppet::Util::ExecutionStub.set do |command, options|
+      command.should == [true_command]
+      stub_call_count += 1
+      'stub called'
+    end
+    Puppet::Util.execute([true_command]).should == 'stub called'
+    stub_call_count.should == 1
+    Puppet::Util::ExecutionStub.reset
+    Puppet::Util::ExecutionStub.current_value.should == nil
+    Puppet::Util.execute([true_command]).should == ''
+    stub_call_count.should == 1
+  end
+end
-- 
cgit 


From 9d2fceb7141e4cc7a6215aa2529239eb2eb6c8fd Mon Sep 17 00:00:00 2001
From: Paul Berry <paul@puppetlabs.com>
Date: Tue, 1 Mar 2011 14:06:42 -0800
Subject: Maint: Begin adding integration tests for the mount provider

These tests form a starting point for integration testing the mount
provider, using the new Puppet::Util::ExecutionStub mechanism to
simulate the state of the machine in response to the execution of
"mount" and "umount" commands.  The tests currently work around some
known bugs (6628, 6632, and 6633).

Reviewed-by: Max Martin <max@puppetlabs.com>
---
 spec/integration/provider/mount_spec.rb | 93 +++++++++++++++++++++++++++++++++
 1 file changed, 93 insertions(+)
 create mode 100644 spec/integration/provider/mount_spec.rb

(limited to 'spec')

diff --git a/spec/integration/provider/mount_spec.rb b/spec/integration/provider/mount_spec.rb
new file mode 100644
index 000000000..69a9eeb56
--- /dev/null
+++ b/spec/integration/provider/mount_spec.rb
@@ -0,0 +1,93 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+require 'puppet/file_bucket/dipper'
+
+describe "mount provider (integration)" do
+  include PuppetSpec::Files
+
+  before :each do
+    @fake_fstab = tmpfile('fstab')
+    File.open(@fake_fstab, 'w') do |f|
+      # leave file empty
+    end
+    Puppet::Type.type(:mount).defaultprovider.stubs(:default_target).returns(@fake_fstab)
+    Facter.stubs(:value).with(:operatingsystem).returns('Darwin')
+    Puppet::Util::ExecutionStub.set do |command, options|
+      case command[0]
+      when '/sbin/mount'
+        if command.length == 1
+          if @mounted
+            "/dev/disk1s1 on /Volumes/foo_disk (msdos, local)\n"
+          else
+            ''
+          end
+        else
+          command.length.should == 4
+          command[1].should == '-o'
+          command[2].should == 'local'
+          command[3].should == '/Volumes/foo_disk'
+          @mounted.should == false # verify that we don't try to call "mount" redundantly
+          check_fstab
+          @mounted = true
+          ''
+        end
+      when '/sbin/umount'
+        fail "unexpected umount" unless @umount_permitted
+        command.length.should == 2
+        command[1].should == '/Volumes/foo_disk'
+        @mounted = false
+        ''
+      else
+        fail "Unexpected command #{command.inspect} executed"
+      end
+    end
+  end
+
+  after :each do
+    Puppet::Type::Mount::ProviderParsed.clear # Work around bug #6628
+  end
+
+  def check_fstab
+    # Verify that the fake fstab has the expected data in it
+    File.read(@fake_fstab).lines.reject { |x| x =~ /^#/ }.should == ["/dev/disk1s1\t/Volumes/foo_disk\tmsdos\tlocal\t0\t0\n"]
+  end
+
+  def run_in_catalog(ensure_setting)
+    resource = Puppet::Type.type(:mount).new(:name => "/Volumes/foo_disk", :ensure => ensure_setting,
+                                             :device => "/dev/disk1s1", :options => "local", :fstype => "msdos")
+    Puppet::FileBucket::Dipper.any_instance.stubs(:backup) # Don't backup to the filebucket
+    resource.expects(:err).never
+    catalog = Puppet::Resource::Catalog.new
+    catalog.host_config = false # Stop Puppet from doing a bunch of magic
+    catalog.add_resource resource
+    catalog.apply
+  end
+
+  [:defined, :present].each do |ensure_setting|
+    describe "When setting ensure => #{ensure_setting}" do
+      it "should create an fstab entry if none exists" do
+        @mounted = false
+        @umount_permitted = false
+        run_in_catalog(ensure_setting)
+        @mounted.should == false
+        check_fstab
+      end
+    end
+  end
+
+  it "should be able to create and mount a brand new mount point" do
+    @mounted = false
+    @umount_permitted = true # Work around bug #6632
+    run_in_catalog(:mounted)
+    @mounted.should == true
+    check_fstab
+  end
+
+  it "should be able to create an fstab entry for an already-mounted device" do
+    @mounted = true
+    @umount_permitted = true # Work around bug #6633
+    run_in_catalog(:mounted)
+    @mounted.should == true
+    check_fstab
+  end
+end
-- 
cgit 


From bd5517dd9cd8e10f488713d9654957746e687378 Mon Sep 17 00:00:00 2001
From: Paul Berry <paul@puppetlabs.com>
Date: Mon, 7 Mar 2011 17:56:41 -0800
Subject: Adjust Darwin mount provider tests to pass on Linux

mount, and umount are located under /bin, instead of /sbin on Linux, so we
adjust the ExecutionStub to accept either location.

Paired-with: Jacob Helwig <jacob@puppetlabs.com>
---
 spec/integration/provider/mount_spec.rb | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'spec')

diff --git a/spec/integration/provider/mount_spec.rb b/spec/integration/provider/mount_spec.rb
index 69a9eeb56..c28707dd9 100644
--- a/spec/integration/provider/mount_spec.rb
+++ b/spec/integration/provider/mount_spec.rb
@@ -14,7 +14,7 @@ describe "mount provider (integration)" do
     Facter.stubs(:value).with(:operatingsystem).returns('Darwin')
     Puppet::Util::ExecutionStub.set do |command, options|
       case command[0]
-      when '/sbin/mount'
+      when %r{/s?bin/mount}
         if command.length == 1
           if @mounted
             "/dev/disk1s1 on /Volumes/foo_disk (msdos, local)\n"
@@ -31,7 +31,7 @@ describe "mount provider (integration)" do
           @mounted = true
           ''
         end
-      when '/sbin/umount'
+      when %r{/s?bin/umount}
         fail "unexpected umount" unless @umount_permitted
         command.length.should == 2
         command[1].should == '/Volumes/foo_disk'
-- 
cgit 


From 5ef10315705b8e4d69d13b8df86b9585f2bcc29a Mon Sep 17 00:00:00 2001
From: Paul Berry <paul@puppetlabs.com>
Date: Tue, 8 Mar 2011 11:35:58 -0800
Subject: (#6632) Adding a new mount no longer causes error with umount

There were two problems:

* In lib/puppet/type/mount.rb, we were calling provider.mounted? to
  determine whether we needed to execute "mount" after updating the
  in-memory fstab record.  This wasn't working properly because
  provider.mounted? makes its decision based on the data stored in the
  in-memory fstab record.  Since the fstab record had just been
  updated, provider.mounted? was incorrectly returning true even
  though the device wasn't actually mounted.  Fixed this by checking
  provider.mounted? before updating the in-memory fstab record.

* Calling mount from this point in lib/puppet/type/mount.rb is
  actually too early, because even though the in-memory fstab record
  has been created, its contents have not been written to `/etc/fstab`
  yet.  Fixed this by storing a :needs_mount entry in the
  property_hash and checking it at the end of the flush() method.

Reviewed-by: Jacob Helwig <jacob@puppetlabs.com>
---
 spec/integration/provider/mount_spec.rb |  3 ++-
 spec/unit/type/mount_spec.rb            | 34 ++++-----------------------------
 2 files changed, 6 insertions(+), 31 deletions(-)

(limited to 'spec')

diff --git a/spec/integration/provider/mount_spec.rb b/spec/integration/provider/mount_spec.rb
index c28707dd9..518b2956f 100644
--- a/spec/integration/provider/mount_spec.rb
+++ b/spec/integration/provider/mount_spec.rb
@@ -35,6 +35,7 @@ describe "mount provider (integration)" do
         fail "unexpected umount" unless @umount_permitted
         command.length.should == 2
         command[1].should == '/Volumes/foo_disk'
+        @mounted.should == true # "umount" doesn't work when device not mounted (see #6632)
         @mounted = false
         ''
       else
@@ -77,7 +78,7 @@ describe "mount provider (integration)" do
 
   it "should be able to create and mount a brand new mount point" do
     @mounted = false
-    @umount_permitted = true # Work around bug #6632
+    @umount_permitted = true # Work around bug #6633
     run_in_catalog(:mounted)
     @mounted.should == true
     check_fstab
diff --git a/spec/unit/type/mount_spec.rb b/spec/unit/type/mount_spec.rb
index 7f9a0eba6..fdb67f7d5 100755
--- a/spec/unit/type/mount_spec.rb
+++ b/spec/unit/type/mount_spec.rb
@@ -65,7 +65,8 @@ end
 
 describe Puppet::Type.type(:mount)::Ensure do
   before :each do
-    @provider = stub 'provider', :class => Puppet::Type.type(:mount).defaultprovider, :clear => nil, :satisfies? => true, :name => :mock
+    provider_properties = {}
+    @provider = stub 'provider', :class => Puppet::Type.type(:mount).defaultprovider, :clear => nil, :satisfies? => true, :name => :mock, :property_hash => provider_properties
     Puppet::Type.type(:mount).defaultprovider.stubs(:new).returns(@provider)
     @mount = Puppet::Type.type(:mount).new(:name => "yay", :check => :ensure)
 
@@ -93,11 +94,12 @@ describe Puppet::Type.type(:mount)::Ensure do
       @provider.stubs(:mounted?).returns([:mounted,:ghost].include? options[:from])
       @provider.expects(:create).times(options[:create] || 0)
       @provider.expects(:destroy).times(options[:destroy] || 0)
-      @provider.expects(:mount).times(options[:mount] || 0)
+      @provider.expects(:mount).never
       @provider.expects(:unmount).times(options[:unmount] || 0)
       @ensure.stubs(:syncothers)
       @ensure.should = options[:to]
       @ensure.sync
+      (!!@provider.property_hash[:needs_mount]).should == (!!options[:mount])
    end
 
    it "should create itself when changing from :ghost to :present" do
@@ -285,34 +287,6 @@ describe Puppet::Type.type(:mount), "when modifying an existing mount entry" do
     @catalog.apply
   end
 
-  it "should flush changes before mounting" do
-    syncorder = sequence('syncorder')
-    @mount.provider.expects(:options).returns 'soft'
-    @mount.provider.expects(:ensure).returns :unmounted
-    @mount.provider.expects(:mounted?).returns false
-
-    @mount.provider.expects(:options=).in_sequence(syncorder).with 'hard'
-    @mount.expects(:flush).in_sequence(syncorder) # Have to write with no options
-    @mount.provider.expects(:mount).in_sequence(syncorder)
-    @mount.expects(:flush).in_sequence(syncorder) # Call flush again cause we changed everything
-
-    @mount[:ensure] = :mounted
-    @mount[:options] = 'hard'
-
-    @catalog.apply
-  end
-
-  it "should not flush before mounting if there are no other changes" do
-    syncorder = sequence('syncorder')
-    @mount.provider.expects(:ensure).returns :unmounted
-    @mount.provider.expects(:mounted?).returns false
-    @mount.provider.expects(:mount).in_sequence(syncorder)
-    @mount.expects(:flush).in_sequence(syncorder) # Call flush cause we changed everything
-
-    @mount[:ensure] = :mounted
-    @catalog.apply
-  end
-
   it "should umount before flushing changes to disk" do
     syncorder = sequence('syncorder')
     @mount.provider.expects(:options).returns 'soft'
-- 
cgit 


From 92dffb29b50160e429b93f941054e5b74df8c598 Mon Sep 17 00:00:00 2001
From: Jacob Helwig <jacob@puppetlabs.com>
Date: Sat, 5 Mar 2011 12:35:25 -0600
Subject: (#6513) Adjust P::U::Settings test name to reflect what it tests

The 'should interpolate found values using the current environment' wasn't
actually testing what it was describing, since the environment variable is
special cased.

Reviewed-by: Jesse Wolfe <jesse@puppetlabs.com>
---
 spec/unit/util/settings_spec.rb | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'spec')

diff --git a/spec/unit/util/settings_spec.rb b/spec/unit/util/settings_spec.rb
index 7bca44b76..3ed843b0b 100755
--- a/spec/unit/util/settings_spec.rb
+++ b/spec/unit/util/settings_spec.rb
@@ -331,7 +331,7 @@ describe Puppet::Util::Settings do
       @settings.value(:one, "env").should == "envval"
     end
 
-    it "should interpolate found values using the current environment" do
+    it 'should use the current environment for $environment' do
       @settings.setdefaults :main, :myval => ["$environment/foo", "mydocs"]
 
       @settings.value(:myval, "myenv").should == "myenv/foo"
-- 
cgit 


From 64440e58967667426e7294ed38ad16e19812d8c4 Mon Sep 17 00:00:00 2001
From: Jacob Helwig <jacob@puppetlabs.com>
Date: Sat, 5 Mar 2011 12:39:14 -0600
Subject: (#6513) Propagate the environment when doing variable lookup in
 settings

For example with the following:

test.conf:
  [master]
      rrddir = /var/lib/puppet/rrd
      templatedir = /var/lib/puppet/templates
  [env_a]
      templatedir = $rrddir/templates
      rrddir = /tmp/env_a/

The command:
  RUBYLIB=lib bin/puppet master --config ./test.conf --environment env_a --configprint templatedir

originally produced '/var/lib/puppet/rrd/templates' instead of the
expected '/tmp/env_a/templates'

Reviewed-by: Jesse Wolfe <jesse@puppetlabs.com>
---
 spec/unit/util/settings_spec.rb | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

(limited to 'spec')

diff --git a/spec/unit/util/settings_spec.rb b/spec/unit/util/settings_spec.rb
index 3ed843b0b..07b712c08 100755
--- a/spec/unit/util/settings_spec.rb
+++ b/spec/unit/util/settings_spec.rb
@@ -284,7 +284,8 @@ describe Puppet::Util::Settings do
       @settings = Puppet::Util::Settings.new
       @settings.setdefaults :section,
         :config => ["/my/file", "a"],
-        :one => ["ONE", "a"]
+        :one => ["ONE", "a"],
+        :two => ["TWO", "b"]
       FileTest.stubs(:exist?).returns true
       Puppet.stubs(:run_mode).returns stub('run_mode', :name => :mymode)
     end
@@ -337,6 +338,14 @@ describe Puppet::Util::Settings do
       @settings.value(:myval, "myenv").should == "myenv/foo"
     end
 
+    it "should interpolate found values using the current environment" do
+      text = "[main]\none = mainval\n[myname]\none = nameval\ntwo = $one/two\n"
+      @settings.stubs(:read_file).returns(text)
+      @settings.parse
+
+      @settings.value(:two, "myname").should == "nameval/two"
+    end
+
     it "should return values in a specified environment before values in the main or name sections" do
       text = "[env]\none = envval\n[main]\none = mainval\n[myname]\none = nameval\n"
       @settings.stubs(:read_file).returns(text)
-- 
cgit 


From 1ef83cb750896f997a347a144e20aa6c96daf171 Mon Sep 17 00:00:00 2001
From: Paul Berry <paul@puppetlabs.com>
Date: Tue, 8 Mar 2011 13:26:43 -0800
Subject: Added integration tests for the mount provider

Paired-with: Max Martin <max@puppetlabs.com>
---
 spec/integration/provider/mount_spec.rb | 99 +++++++++++++++++++++------------
 1 file changed, 64 insertions(+), 35 deletions(-)

(limited to 'spec')

diff --git a/spec/integration/provider/mount_spec.rb b/spec/integration/provider/mount_spec.rb
index 518b2956f..a62505d6d 100644
--- a/spec/integration/provider/mount_spec.rb
+++ b/spec/integration/provider/mount_spec.rb
@@ -5,11 +5,17 @@ require 'puppet/file_bucket/dipper'
 describe "mount provider (integration)" do
   include PuppetSpec::Files
 
-  before :each do
-    @fake_fstab = tmpfile('fstab')
+  def create_fake_fstab(initially_contains_entry)
     File.open(@fake_fstab, 'w') do |f|
-      # leave file empty
+      if initially_contains_entry
+        f.puts("/dev/disk1s1\t/Volumes/foo_disk\tmsdos\tlocal\t0\t0")
+      end
     end
+  end
+
+  before :each do
+    @fake_fstab = tmpfile('fstab')
+    @current_options = "local"
     Puppet::Type.type(:mount).defaultprovider.stubs(:default_target).returns(@fake_fstab)
     Facter.stubs(:value).with(:operatingsystem).returns('Darwin')
     Puppet::Util::ExecutionStub.set do |command, options|
@@ -17,22 +23,21 @@ describe "mount provider (integration)" do
       when %r{/s?bin/mount}
         if command.length == 1
           if @mounted
-            "/dev/disk1s1 on /Volumes/foo_disk (msdos, local)\n"
+            "/dev/disk1s1 on /Volumes/foo_disk (msdos, #{@current_options})\n"
           else
             ''
           end
         else
           command.length.should == 4
           command[1].should == '-o'
-          command[2].should == 'local'
           command[3].should == '/Volumes/foo_disk'
           @mounted.should == false # verify that we don't try to call "mount" redundantly
-          check_fstab
+          @current_options = command[2]
+          check_fstab(true)
           @mounted = true
           ''
         end
       when %r{/s?bin/umount}
-        fail "unexpected umount" unless @umount_permitted
         command.length.should == 2
         command[1].should == '/Volumes/foo_disk'
         @mounted.should == true # "umount" doesn't work when device not mounted (see #6632)
@@ -48,14 +53,15 @@ describe "mount provider (integration)" do
     Puppet::Type::Mount::ProviderParsed.clear # Work around bug #6628
   end
 
-  def check_fstab
+  def check_fstab(expected_to_be_present)
     # Verify that the fake fstab has the expected data in it
-    File.read(@fake_fstab).lines.reject { |x| x =~ /^#/ }.should == ["/dev/disk1s1\t/Volumes/foo_disk\tmsdos\tlocal\t0\t0\n"]
+    expected_data = expected_to_be_present ? ["/dev/disk1s1\t/Volumes/foo_disk\tmsdos\t#{@desired_options}\t0\t0"] : []
+    File.read(@fake_fstab).lines.map(&:chomp).reject { |x| x =~ /^#|^$/ }.should == expected_data
   end
 
-  def run_in_catalog(ensure_setting)
-    resource = Puppet::Type.type(:mount).new(:name => "/Volumes/foo_disk", :ensure => ensure_setting,
-                                             :device => "/dev/disk1s1", :options => "local", :fstype => "msdos")
+  def run_in_catalog(settings)
+    resource = Puppet::Type.type(:mount).new(settings.merge(:name => "/Volumes/foo_disk",
+                                             :device => "/dev/disk1s1", :fstype => "msdos"))
     Puppet::FileBucket::Dipper.any_instance.stubs(:backup) # Don't backup to the filebucket
     resource.expects(:err).never
     catalog = Puppet::Resource::Catalog.new
@@ -64,31 +70,54 @@ describe "mount provider (integration)" do
     catalog.apply
   end
 
-  [:defined, :present].each do |ensure_setting|
-    describe "When setting ensure => #{ensure_setting}" do
-      it "should create an fstab entry if none exists" do
-        @mounted = false
-        @umount_permitted = false
-        run_in_catalog(ensure_setting)
-        @mounted.should == false
-        check_fstab
+  [false, true].each do |initial_state|
+    describe "When initially #{initial_state ? 'mounted' : 'unmounted'}" do
+      before :each do
+        @mounted = initial_state
       end
-    end
-  end
 
-  it "should be able to create and mount a brand new mount point" do
-    @mounted = false
-    @umount_permitted = true # Work around bug #6633
-    run_in_catalog(:mounted)
-    @mounted.should == true
-    check_fstab
-  end
+      [false, true].each do |initial_fstab_entry|
+        describe "When there is #{initial_fstab_entry ? 'an' : 'no'} initial fstab entry" do
+          before :each do
+            create_fake_fstab(initial_fstab_entry)
+          end
 
-  it "should be able to create an fstab entry for an already-mounted device" do
-    @mounted = true
-    @umount_permitted = true # Work around bug #6633
-    run_in_catalog(:mounted)
-    @mounted.should == true
-    check_fstab
+          [:defined, :present, :mounted, :unmounted, :absent].each do |ensure_setting|
+            expected_final_state = case ensure_setting
+              when :mounted
+                true
+              when :unmounted, :absent
+                false
+              when :defined, :present
+                initial_state
+              else
+                fail "Unknown ensure_setting #{ensure_setting}"
+            end
+            expected_fstab_data = (ensure_setting != :absent)
+            describe "When setting ensure => #{ensure_setting}" do
+              ["local", "journaled"].each do |options_setting|
+                describe "When setting options => #{options_setting}" do
+                  it "should leave the system in the #{expected_final_state ? 'mounted' : 'unmounted'} state, #{expected_fstab_data ? 'with' : 'without'} data in /etc/fstab" do
+                    @desired_options = options_setting
+                    run_in_catalog(:ensure=>ensure_setting, :options => options_setting)
+                    @mounted.should == expected_final_state
+                    check_fstab(expected_fstab_data)
+                    if @mounted
+                      if ![:defined, :present].include?(ensure_setting)
+                        @current_options.should == @desired_options
+                      elsif initial_fstab_entry
+                        @current_options.should == @desired_options
+                      else
+                        @current_options.should == 'local' #Workaround for #6645
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
   end
 end
-- 
cgit 


From 8ce30c83ddba87ba7e2622a46f27143159132789 Mon Sep 17 00:00:00 2001
From: Nick Lewis <nick@puppetlabs.com>
Date: Mon, 7 Mar 2011 15:19:20 -0800
Subject: (#6338) Add an InventoryActiveRecord terminus for Facts

So far this terminus only supports find and save. Search is forthcoming. It
uses two new tables (inventory_host and inventory_facts) so that it won't
interact with storedconfigs.

Paired-With: Jacob Helwig
---
 .../facts/inventory_active_record_spec.rb          | 99 ++++++++++++++++++++++
 1 file changed, 99 insertions(+)
 create mode 100644 spec/unit/indirector/facts/inventory_active_record_spec.rb

(limited to 'spec')

diff --git a/spec/unit/indirector/facts/inventory_active_record_spec.rb b/spec/unit/indirector/facts/inventory_active_record_spec.rb
new file mode 100644
index 000000000..b97bada19
--- /dev/null
+++ b/spec/unit/indirector/facts/inventory_active_record_spec.rb
@@ -0,0 +1,99 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'sqlite3' rescue nil
+require 'tempfile'
+require 'puppet/rails'
+
+describe "Puppet::Node::Facts::InventoryActiveRecord", :if => (Puppet.features.rails? and defined? SQLite3) do
+  let(:terminus) { Puppet::Node::Facts::InventoryActiveRecord.new }
+
+  before :all do
+    require 'puppet/indirector/facts/inventory_active_record'
+    @dbfile = Tempfile.new("testdb")
+    @dbfile.close
+  end
+
+  after :all do
+    Puppet::Node::Facts.indirection.reset_terminus_class
+    @dbfile.unlink
+  end
+
+  before :each do
+    Puppet::Node::Facts.terminus_class = :inventory_active_record
+    Puppet[:dbadapter]  = 'sqlite3'
+    Puppet[:dblocation] = @dbfile.path
+    Puppet[:railslog] = "/dev/null"
+    Puppet::Rails.init
+  end
+
+  after :each do
+    Puppet::Rails.teardown
+  end
+
+  describe "#save" do
+    it "should use an existing host if possible" do
+      host = Puppet::Rails::InventoryHost.new(:name => "foo", :timestamp => Time.now)
+      host.save
+      Puppet::Node::Facts.new("foo", "uptime_days" => "60", "kernel" => "Darwin").save
+
+      Puppet::Rails::InventoryHost.count.should == 1
+      Puppet::Rails::InventoryHost.first.should == host
+    end
+
+    it "should create a new host if one can't be found" do
+      # This test isn't valid if there are hosts to begin with
+      Puppet::Rails::InventoryHost.count.should == 0
+
+      Puppet::Node::Facts.new("foo", "uptime_days" => "60", "kernel" => "Darwin").save
+
+      Puppet::Rails::InventoryHost.count.should == 1
+      Puppet::Rails::InventoryHost.first.name.should == "foo"
+    end
+
+    it "should save the facts" do
+      Puppet::Node::Facts.new("foo", "uptime_days" => "60", "kernel" => "Darwin").save
+
+      Puppet::Rails::InventoryFact.all.map{|f| [f.name,f.value]}.should =~ [["uptime_days","60"],["kernel","Darwin"]]
+    end
+
+    it "should remove the previous facts for an existing host" do
+      Puppet::Node::Facts.new("foo", "uptime_days" => "30", "kernel" => "Darwin").save
+      bar_facts = Puppet::Node::Facts.new("bar", "uptime_days" => "35", "kernel" => "Linux")
+      foo_facts = Puppet::Node::Facts.new("foo", "uptime_days" => "60", "is_virtual" => "false")
+      bar_facts.save
+      foo_facts.save
+
+      Puppet::Node::Facts.find("bar").should == bar_facts
+      Puppet::Node::Facts.find("foo").should == foo_facts
+      Puppet::Rails::InventoryFact.all.map{|f| [f.name,f.value]}.should_not include(["uptime_days", "30"], ["kernel", "Darwin"])
+    end
+
+    it "should not replace the node's facts if something goes wrong" do
+    end
+  end
+
+  describe "#find" do
+    before do
+      @foo_facts = Puppet::Node::Facts.new("foo", "uptime_days" => "60", "kernel" => "Darwin")
+      @bar_facts = Puppet::Node::Facts.new("bar", "uptime_days" => "30", "kernel" => "Linux")
+      @foo_facts.save
+      @bar_facts.save
+    end
+
+    it "should identify facts by host name" do
+      Puppet::Node::Facts.find("foo").should == @foo_facts
+    end
+
+    it "should return nil if no host instance can be found" do
+      Puppet::Node::Facts.find("non-existent host").should == nil
+    end
+
+    it "should convert all single-member arrays into non-arrays" do
+      Puppet::Node::Facts.new("array", "fact1" => ["value1"]).save
+
+      Puppet::Node::Facts.find("array").values["fact1"].should == "value1"
+    end
+  end
+end
+
-- 
cgit 


From f83636698229241b2ab35849437f3e515f6ac5c1 Mon Sep 17 00:00:00 2001
From: Nick Lewis <nick@puppetlabs.com>
Date: Mon, 7 Mar 2011 16:42:53 -0800
Subject: (#6338) Implement search for InventoryActiveRecord facts terminus

Paired-With: Max Martin
Reviewed-By: Jacob Helwig
---
 .../facts/inventory_active_record_spec.rb          | 52 ++++++++++++++++++++++
 1 file changed, 52 insertions(+)

(limited to 'spec')

diff --git a/spec/unit/indirector/facts/inventory_active_record_spec.rb b/spec/unit/indirector/facts/inventory_active_record_spec.rb
index b97bada19..7fb55561d 100644
--- a/spec/unit/indirector/facts/inventory_active_record_spec.rb
+++ b/spec/unit/indirector/facts/inventory_active_record_spec.rb
@@ -95,5 +95,57 @@ describe "Puppet::Node::Facts::InventoryActiveRecord", :if => (Puppet.features.r
       Puppet::Node::Facts.find("array").values["fact1"].should == "value1"
     end
   end
+
+  describe "#search" do
+
+    it "should return node names that match 'equal' constraints" do
+      Puppet::Node::Facts.new("foo", "fact1" => "value1", "fact2" => "value2", "fact3" => "value3").save
+      Puppet::Node::Facts.new("bar", "fact1" => "value2").save
+      Puppet::Node::Facts.new("baz", "fact1" => "value1", "fact2" => "value1", "fact3" => "value1").save
+
+      request = Puppet::Indirector::Request.new(:facts, :search, nil,
+                                                {'facts.fact1.eq' => 'value1',
+                                                 'facts.fact2.eq' => 'value2',
+                                                 'facts.fact3.eq' => 'value3'})
+      terminus.search(request).should =~ ["foo"]
+    end
+
+    it "should return node names that match 'not equal' constraints" do
+      Puppet::Node::Facts.new("foo", "fact1" => "value1", "fact2" => "value2", "fact3" => "value3").save
+      Puppet::Node::Facts.new("bar", "fact1" => "value2").save
+      Puppet::Node::Facts.new("baz", "fact1" => "value1", "fact2" => "value1", "fact3" => "value1").save
+      Puppet::Node::Facts.new("bang", "fact1" => "value1", "fact2" => "value2", "fact3" => "value1").save
+
+      request = Puppet::Indirector::Request.new(:facts, :search, nil,
+                                                {'facts.fact1.ne' => 'value3',
+                                                 'facts.fact2.ne' => 'value1',
+                                                 'facts.fact3.ne' => 'value2'})
+      terminus.search(request).should =~ ["foo","bang"]
+    end
+
+    it "should return node names that match strict inequality constraints" do
+      Puppet::Node::Facts.new("foo", "uptime_days" => "30").save
+      Puppet::Node::Facts.new("bar", "uptime_days" => "60").save
+      Puppet::Node::Facts.new("baz", "uptime_days" => "90").save
+
+      request = Puppet::Indirector::Request.new(:facts, :search, nil,
+                                                {'facts.uptime_days.gt' => '20',
+                                                 'facts.uptime_days.lt' => '70'})
+
+      terminus.search(request).should =~ ["foo","bar"]
+    end
+
+    it "should return node names that match non-strict inequality constraints" do
+      Puppet::Node::Facts.new("foo", "uptime_days" => "30").save
+      Puppet::Node::Facts.new("bar", "uptime_days" => "60").save
+      Puppet::Node::Facts.new("baz", "uptime_days" => "90").save
+
+      request = Puppet::Indirector::Request.new(:facts, :search, nil,
+                                                {'facts.uptime_days.ge' => '30',
+                                                 'facts.uptime_days.le' => '60'})
+
+      terminus.search(request).should =~ ["foo","bar"]
+    end
+  end
 end
 
-- 
cgit 


From 880d0c6cbd20758e02848d1fa61966402dc44dc0 Mon Sep 17 00:00:00 2001
From: Nick Lewis <nick@puppetlabs.com>
Date: Mon, 7 Mar 2011 17:28:43 -0800
Subject: (#6338) Support searching on metadata in InventoryActiveRecord
 terminus

Timestamps are currently the only supported metadata for searching.

Paired-With: Max Martin
Reviewed-By: Jacob Helwig
---
 .../facts/inventory_active_record_spec.rb          | 89 +++++++++++++---------
 1 file changed, 55 insertions(+), 34 deletions(-)

(limited to 'spec')

diff --git a/spec/unit/indirector/facts/inventory_active_record_spec.rb b/spec/unit/indirector/facts/inventory_active_record_spec.rb
index 7fb55561d..69d614023 100644
--- a/spec/unit/indirector/facts/inventory_active_record_spec.rb
+++ b/spec/unit/indirector/facts/inventory_active_record_spec.rb
@@ -97,54 +97,75 @@ describe "Puppet::Node::Facts::InventoryActiveRecord", :if => (Puppet.features.r
   end
 
   describe "#search" do
+    def search_request(conditions)
+      Puppet::Indirector::Request.new(:facts, :search, nil, conditions)
+    end
 
-    it "should return node names that match 'equal' constraints" do
-      Puppet::Node::Facts.new("foo", "fact1" => "value1", "fact2" => "value2", "fact3" => "value3").save
-      Puppet::Node::Facts.new("bar", "fact1" => "value2").save
-      Puppet::Node::Facts.new("baz", "fact1" => "value1", "fact2" => "value1", "fact3" => "value1").save
+    before :each do
+      @now = Time.now
+      @foo = Puppet::Node::Facts.new("foo", "fact1" => "value1", "fact2" => "value2", "uptime_days" => "30")
+      @bar = Puppet::Node::Facts.new("bar", "fact1" => "value1", "uptime_days" => "60")
+      @baz = Puppet::Node::Facts.new("baz", "fact1" => "value2", "fact2" => "value1", "uptime_days" => "90")
+      @bat = Puppet::Node::Facts.new("bat")
+      @foo.timestamp = @now - 3600*1
+      @bar.timestamp = @now - 3600*3
+      @baz.timestamp = @now - 3600*5
+      @bat.timestamp = @now - 3600*7
+      @foo.save
+      @bar.save
+      @baz.save
+      @bat.save
+    end
 
-      request = Puppet::Indirector::Request.new(:facts, :search, nil,
-                                                {'facts.fact1.eq' => 'value1',
-                                                 'facts.fact2.eq' => 'value2',
-                                                 'facts.fact3.eq' => 'value3'})
-      terminus.search(request).should =~ ["foo"]
+    it "should return node names that match 'equal' constraints" do
+      request = search_request('facts.fact1.eq' => 'value1',
+                               'facts.fact2.eq' => 'value2')
+      terminus.search(request).should == ["foo"]
     end
 
     it "should return node names that match 'not equal' constraints" do
-      Puppet::Node::Facts.new("foo", "fact1" => "value1", "fact2" => "value2", "fact3" => "value3").save
-      Puppet::Node::Facts.new("bar", "fact1" => "value2").save
-      Puppet::Node::Facts.new("baz", "fact1" => "value1", "fact2" => "value1", "fact3" => "value1").save
-      Puppet::Node::Facts.new("bang", "fact1" => "value1", "fact2" => "value2", "fact3" => "value1").save
-
-      request = Puppet::Indirector::Request.new(:facts, :search, nil,
-                                                {'facts.fact1.ne' => 'value3',
-                                                 'facts.fact2.ne' => 'value1',
-                                                 'facts.fact3.ne' => 'value2'})
-      terminus.search(request).should =~ ["foo","bang"]
+      request = search_request('facts.fact1.ne' => 'value2')
+      terminus.search(request).should == ["bar","foo"]
     end
 
     it "should return node names that match strict inequality constraints" do
-      Puppet::Node::Facts.new("foo", "uptime_days" => "30").save
-      Puppet::Node::Facts.new("bar", "uptime_days" => "60").save
-      Puppet::Node::Facts.new("baz", "uptime_days" => "90").save
+      request = search_request('facts.uptime_days.gt' => '20',
+                               'facts.uptime_days.lt' => '70')
+      terminus.search(request).should == ["bar","foo"]
+    end
 
-      request = Puppet::Indirector::Request.new(:facts, :search, nil,
-                                                {'facts.uptime_days.gt' => '20',
-                                                 'facts.uptime_days.lt' => '70'})
+    it "should return node names that match non-strict inequality constraints" do
+      request = search_request('facts.uptime_days.ge' => '30',
+                               'facts.uptime_days.le' => '60')
+      terminus.search(request).should == ["bar","foo"]
+    end
 
-      terminus.search(request).should =~ ["foo","bar"]
+    it "should return node names whose facts are within a given timeframe" do
+      request = search_request('meta.timestamp.ge' => @now - 3600*5,
+                               'meta.timestamp.le' => @now - 3600*1)
+      terminus.search(request).should == ["bar","baz","foo"]
     end
 
-    it "should return node names that match non-strict inequality constraints" do
-      Puppet::Node::Facts.new("foo", "uptime_days" => "30").save
-      Puppet::Node::Facts.new("bar", "uptime_days" => "60").save
-      Puppet::Node::Facts.new("baz", "uptime_days" => "90").save
+    it "should return node names whose facts are from a specific time" do
+      request = search_request('meta.timestamp.eq' => @now - 3600*3)
+      terminus.search(request).should == ["bar"]
+    end
 
-      request = Puppet::Indirector::Request.new(:facts, :search, nil,
-                                                {'facts.uptime_days.ge' => '30',
-                                                 'facts.uptime_days.le' => '60'})
+    it "should return node names whose facts are not from a specific time" do
+      request = search_request('meta.timestamp.ne' => @now - 3600*1)
+      terminus.search(request).should == ["bar","bat","baz"]
+    end
+
+    it "should perform strict searches on nodes by timestamp" do
+      request = search_request('meta.timestamp.gt' => @now - 3600*5,
+                               'meta.timestamp.lt' => @now - 3600*1)
+      terminus.search(request).should == ["bar"]
+    end
 
-      terminus.search(request).should =~ ["foo","bar"]
+    it "should search nodes based on both facts and timestamp values" do
+      request = search_request('facts.uptime_days.gt' => '45',
+                               'meta.timestamp.lt'    => @now - 3600*4)
+      terminus.search(request).should == ["baz"]
     end
   end
 end
-- 
cgit 


From 7764412aacb4132d40561e2ba47d52f5e333c16e Mon Sep 17 00:00:00 2001
From: Max Martin <max@puppetlabs.com>
Date: Tue, 8 Mar 2011 16:20:53 -0800
Subject: maint:Refactor of mount provider integration tests

When adding a test for #6309, decided to refactor mount provider
integration tests by adding return value to check_fstab method.

Paired-with:Paul Berry <paul@puppetlabs.com>
---
 spec/integration/provider/mount_spec.rb | 38 ++++++++++++++++++++++++++++-----
 1 file changed, 33 insertions(+), 5 deletions(-)

(limited to 'spec')

diff --git a/spec/integration/provider/mount_spec.rb b/spec/integration/provider/mount_spec.rb
index a62505d6d..d6f25fe1d 100644
--- a/spec/integration/provider/mount_spec.rb
+++ b/spec/integration/provider/mount_spec.rb
@@ -16,6 +16,7 @@ describe "mount provider (integration)" do
   before :each do
     @fake_fstab = tmpfile('fstab')
     @current_options = "local"
+    @current_device = "/dev/disk1s1"
     Puppet::Type.type(:mount).defaultprovider.stubs(:default_target).returns(@fake_fstab)
     Facter.stubs(:value).with(:operatingsystem).returns('Darwin')
     Puppet::Util::ExecutionStub.set do |command, options|
@@ -23,7 +24,7 @@ describe "mount provider (integration)" do
       when %r{/s?bin/mount}
         if command.length == 1
           if @mounted
-            "/dev/disk1s1 on /Volumes/foo_disk (msdos, #{@current_options})\n"
+            "#{@current_device} on /Volumes/foo_disk (msdos, #{@current_options})\n"
           else
             ''
           end
@@ -33,7 +34,7 @@ describe "mount provider (integration)" do
           command[3].should == '/Volumes/foo_disk'
           @mounted.should == false # verify that we don't try to call "mount" redundantly
           @current_options = command[2]
-          check_fstab(true)
+          @current_device = check_fstab(true)
           @mounted = true
           ''
         end
@@ -55,8 +56,16 @@ describe "mount provider (integration)" do
 
   def check_fstab(expected_to_be_present)
     # Verify that the fake fstab has the expected data in it
-    expected_data = expected_to_be_present ? ["/dev/disk1s1\t/Volumes/foo_disk\tmsdos\t#{@desired_options}\t0\t0"] : []
-    File.read(@fake_fstab).lines.map(&:chomp).reject { |x| x =~ /^#|^$/ }.should == expected_data
+    fstab_contents = File.read(@fake_fstab).lines.map(&:chomp).reject { |x| x =~ /^#|^$/ }
+    if expected_to_be_present
+      fstab_contents.length().should == 1
+      device, rest_of_line = fstab_contents[0].split(/\t/,2)
+      rest_of_line.should == "/Volumes/foo_disk\tmsdos\t#{@desired_options}\t0\t0"
+      device
+    else
+      fstab_contents.length().should == 0
+      nil
+    end
   end
 
   def run_in_catalog(settings)
@@ -101,7 +110,11 @@ describe "mount provider (integration)" do
                     @desired_options = options_setting
                     run_in_catalog(:ensure=>ensure_setting, :options => options_setting)
                     @mounted.should == expected_final_state
-                    check_fstab(expected_fstab_data)
+                    if expected_fstab_data
+                      check_fstab(expected_fstab_data).should == "/dev/disk1s1"
+                    else
+                      check_fstab(expected_fstab_data).should == nil
+                    end
                     if @mounted
                       if ![:defined, :present].include?(ensure_setting)
                         @current_options.should == @desired_options
@@ -120,4 +133,19 @@ describe "mount provider (integration)" do
       end
     end
   end
+
+  describe "When the wrong device is mounted" do
+    it "should remount the correct device" do
+      pending "Due to bug 6309"
+      @mounted = true
+      @current_device = "/dev/disk2s2"
+      create_fake_fstab(true)
+      @desired_options = "local"
+      run_in_catalog(:ensure=>:mounted, :options=>'local')
+      @current_device.should=="/dev/disk1s1"
+      @mounted.should==true
+      @current_options.should=='local'
+      check_fstab(true).should == "/dev/disk1s1"
+    end
+  end
 end
-- 
cgit 


From a3f2357215b15f318500d6637f393dad0d4a4181 Mon Sep 17 00:00:00 2001
From: Matt Robinson <matt@puppetlabs.com>
Date: Tue, 8 Mar 2011 16:59:12 -0800
Subject: maint: Remove spec run noise

There were some warnings and stack traces in the spec output that aren't
necessary.

The only interesting fix is of the message:

lib/puppet/module.rb:79 warning: multiple values for a block parameter (0 for 1)
   from lib/puppet/util/logging.rb:30

If you call any form of logging on a module you end calling the file
method on the module just because logging always checks for that method
and calls it if it's defined, but in this case it's not defined in the
way that logging expected so passes the wrong paramters.

The easy solution is just to call logging on Puppet, which makes sense
in this case anyway, and I don't think it's worth a separate ticket to
deal with that logging warning.

Reviewed-by: Nick Lewis <nick@puppetlabs.com>
---
 spec/unit/indirector/queue_spec.rb           | 3 +++
 spec/unit/module_spec.rb                     | 4 ++--
 spec/unit/network/handler/fileserver_spec.rb | 2 +-
 spec/unit/parser/parser_spec.rb              | 2 +-
 4 files changed, 7 insertions(+), 4 deletions(-)

(limited to 'spec')

diff --git a/spec/unit/indirector/queue_spec.rb b/spec/unit/indirector/queue_spec.rb
index 00463ee0f..bbe00c75f 100755
--- a/spec/unit/indirector/queue_spec.rb
+++ b/spec/unit/indirector/queue_spec.rb
@@ -114,6 +114,9 @@ describe Puppet::Indirector::Queue, :if => Puppet.features.pson? do
       @store_class.client.expects(:subscribe).yields("foo")
       @store_class.expects(:intern).raises ArgumentError
       Puppet.expects(:err)
+
+      @store_class.expects(:puts)
+
       @store_class.subscribe {|o| o }
     end
   end
diff --git a/spec/unit/module_spec.rb b/spec/unit/module_spec.rb
index 37dad7e25..0b4873f5f 100755
--- a/spec/unit/module_spec.rb
+++ b/spec/unit/module_spec.rb
@@ -367,9 +367,9 @@ describe Puppet::Module do
     mod.stubs(:path).returns "/a/foo"
     FileTest.expects(:exist?).with("/a/foo/plugins").returns true
 
-    mod.expects(:warning)
-
     mod.plugin_directory.should == "/a/foo/plugins"
+    @logs.first.message.should == "using the deprecated 'plugins' directory for ruby extensions; please move to 'lib'"
+    @logs.first.level.should == :warning
   end
 
   it "should default to 'lib' for the plugins directory" do
diff --git a/spec/unit/network/handler/fileserver_spec.rb b/spec/unit/network/handler/fileserver_spec.rb
index b37d4f551..9d34e9cdd 100644
--- a/spec/unit/network/handler/fileserver_spec.rb
+++ b/spec/unit/network/handler/fileserver_spec.rb
@@ -158,7 +158,7 @@ describe Puppet::Network::Handler::FileServer do
     end
 
     it "should not fail for inexistant plugins type" do
-      lambda { @mount.list("puppet/parser",true,false) }.should_not raise_error
+      @mount.list("puppet/parser",true,false)
     end
 
   end
diff --git a/spec/unit/parser/parser_spec.rb b/spec/unit/parser/parser_spec.rb
index 6cc393d91..2ed279fd9 100755
--- a/spec/unit/parser/parser_spec.rb
+++ b/spec/unit/parser/parser_spec.rb
@@ -259,7 +259,7 @@ describe Puppet::Parser do
     before do
       @lexer = stub 'lexer', :line => 50, :file => "/foo/bar", :getcomment => "whev"
       @parser.stubs(:lexer).returns @lexer
-      @class = stub 'class', :use_docs => false
+      @class = Puppet::Resource::Type.new(:hostclass, "myclass", :use_docs => false)
     end
 
     it "should return a new instance of the provided class created with the provided options" do
-- 
cgit 


From 4bd54939ceb4c588b1633117d88472fe48e9dfdf Mon Sep 17 00:00:00 2001
From: James Turnbull <james@lovedthanlost.net>
Date: Wed, 9 Mar 2011 17:56:37 +1100
Subject: Fixed #2645 - Added support for creating system users

On Red Hat, Ubuntu, Debian and deriatives the -r flag
allows creation of "system" users with a UID below that
defined in /etc/login.defs.

This commit adds support for a system parameter and a
system_users feature which can be used like so:

    user { "foo":
      system => true,
      ensure => present,
    }

This will create a user with a lower UID.

The system parameter defaults to false.
---
 spec/unit/provider/user/useradd_spec.rb | 39 ++++++++++++++++++++++++++++++---
 spec/unit/type/user_spec.rb             |  4 ++++
 2 files changed, 40 insertions(+), 3 deletions(-)

(limited to 'spec')

diff --git a/spec/unit/provider/user/useradd_spec.rb b/spec/unit/provider/user/useradd_spec.rb
index 9ebba596c..81ad7d400 100755
--- a/spec/unit/provider/user/useradd_spec.rb
+++ b/spec/unit/provider/user/useradd_spec.rb
@@ -15,6 +15,7 @@ describe provider_class do
   # #1360
   it "should add -o when allowdupe is enabled and the user is being created" do
     @resource.expects(:allowdupe?).returns true
+    @resource.expects(:system?).returns true
     @provider.stubs(:execute)
     @provider.expects(:execute).with { |args| args.include?("-o") }
     @provider.create
@@ -27,6 +28,14 @@ describe provider_class do
     @provider.uid = 150
   end
 
+  it "should add -r when system is enabled" do
+    @resource.expects(:allowdupe?).returns true
+    @resource.expects(:system?).returns true
+    @provider.stubs(:execute)
+    @provider.expects(:execute).with { |args| args.include?("-r") }
+    @provider.create
+  end
+
   it "should set password age rules" do
     provider_class.has_feature :manages_password_age
     @resource = Puppet::Type.type(:user).new :name => "myuser", :password_min_age => 5, :password_max_age => 10, :provider => :useradd
@@ -53,6 +62,23 @@ describe provider_class do
     end
   end
 
+  describe "when checking to add system users" do
+    it "should check system users" do
+      @resource.expects(:system?)
+      @provider.check_system_users
+    end
+
+    it "should return an array with a flag if it's a system user" do
+      @resource.stubs(:system?).returns true
+      @provider.check_system_users.must == ["-r"]
+    end
+
+    it "should return an empty array if it's not a system user" do
+      @resource.stubs(:system?).returns false
+      @provider.check_system_users.must == []
+    end
+  end
+
   describe "when checking manage home" do
     it "should check manage home" do
       @resource.expects(:managehome?)
@@ -88,6 +114,7 @@ describe provider_class do
     before do
       @resource.stubs(:allowdupe?).returns true
       @resource.stubs(:managehome?).returns true
+      @resource.stubs(:system?).returns true
     end
 
     it "should call command with :add" do
@@ -105,6 +132,11 @@ describe provider_class do
       @provider.addcmd
     end
 
+    it "should check and add if it's a system user" do
+      @provider.expects(:check_system_users).returns([])
+      @provider.addcmd
+    end
+
     it "should check and add if home is managed" do
       @provider.expects(:check_manage_home).returns([])
       @provider.addcmd
@@ -120,15 +152,15 @@ describe provider_class do
       @provider.stubs(:add_properties).returns(["-G", "somegroup"])
       @resource.stubs(:[]).with(:name).returns("someuser")
       @resource.stubs(:[]).with(:expiry).returns("somedate")
-      @provider.addcmd.must == ["useradd", "-G", "somegroup", "-o", "-m", '-e somedate', "someuser"]
+      @provider.addcmd.must == ["useradd", "-G", "somegroup", "-o", "-m", '-e somedate', "-r", "someuser"]
     end
 
-    it "should return an array without -e if expery is undefined full command" do
+    it "should return an array without -e if expiry is undefined full command" do
       @provider.stubs(:command).with(:add).returns("useradd")
       @provider.stubs(:add_properties).returns(["-G", "somegroup"])
       @resource.stubs(:[]).with(:name).returns("someuser")
       @resource.stubs(:[]).with(:expiry).returns nil
-      @provider.addcmd.must == ["useradd", "-G", "somegroup", "-o", "-m", "someuser"]
+      @provider.addcmd.must == ["useradd", "-G", "somegroup", "-o", "-m", "-r", "someuser"]
     end
   end
 
@@ -136,6 +168,7 @@ describe provider_class do
     before do
       @resource.stubs(:allowdupe?).returns true
       @resource.stubs(:managehome?).returns true
+      @resource.stubs(:system?).returns true
     end
 
     it "should call command with :pass" do
diff --git a/spec/unit/type/user_spec.rb b/spec/unit/type/user_spec.rb
index 297134446..5a84af443 100755
--- a/spec/unit/type/user_spec.rb
+++ b/spec/unit/type/user_spec.rb
@@ -43,6 +43,10 @@ describe user do
     user.provider_feature(:manages_password_age).should_not be_nil
   end
 
+  it "should have a system_users feature" do
+    user.provider_feature(:system_users).should_not be_nil
+  end
+
   describe "instances" do
     it "should have a valid provider" do
       user.new(:name => "foo").provider.class.ancestors.should be_include(Puppet::Provider)
-- 
cgit 


From 3489412a03fec009bc42222f449077e6f14998a4 Mon Sep 17 00:00:00 2001
From: Nick Lewis <nick@puppetlabs.com>
Date: Wed, 9 Mar 2011 12:55:03 -0800
Subject: maint: Rename InventoryHost to InventoryNode

This had been conflating hosts and nodes, when nodes is the most accurate.
---
 .../facts/inventory_active_record_spec.rb          | 28 +++++++++++-----------
 1 file changed, 14 insertions(+), 14 deletions(-)

(limited to 'spec')

diff --git a/spec/unit/indirector/facts/inventory_active_record_spec.rb b/spec/unit/indirector/facts/inventory_active_record_spec.rb
index 69d614023..ca16606b2 100644
--- a/spec/unit/indirector/facts/inventory_active_record_spec.rb
+++ b/spec/unit/indirector/facts/inventory_active_record_spec.rb
@@ -32,23 +32,23 @@ describe "Puppet::Node::Facts::InventoryActiveRecord", :if => (Puppet.features.r
   end
 
   describe "#save" do
-    it "should use an existing host if possible" do
-      host = Puppet::Rails::InventoryHost.new(:name => "foo", :timestamp => Time.now)
-      host.save
+    it "should use an existing node if possible" do
+      node = Puppet::Rails::InventoryNode.new(:name => "foo", :timestamp => Time.now)
+      node.save
       Puppet::Node::Facts.new("foo", "uptime_days" => "60", "kernel" => "Darwin").save
 
-      Puppet::Rails::InventoryHost.count.should == 1
-      Puppet::Rails::InventoryHost.first.should == host
+      Puppet::Rails::InventoryNode.count.should == 1
+      Puppet::Rails::InventoryNode.first.should == node
     end
 
-    it "should create a new host if one can't be found" do
-      # This test isn't valid if there are hosts to begin with
-      Puppet::Rails::InventoryHost.count.should == 0
+    it "should create a new node if one can't be found" do
+      # This test isn't valid if there are nodes to begin with
+      Puppet::Rails::InventoryNode.count.should == 0
 
       Puppet::Node::Facts.new("foo", "uptime_days" => "60", "kernel" => "Darwin").save
 
-      Puppet::Rails::InventoryHost.count.should == 1
-      Puppet::Rails::InventoryHost.first.name.should == "foo"
+      Puppet::Rails::InventoryNode.count.should == 1
+      Puppet::Rails::InventoryNode.first.name.should == "foo"
     end
 
     it "should save the facts" do
@@ -57,7 +57,7 @@ describe "Puppet::Node::Facts::InventoryActiveRecord", :if => (Puppet.features.r
       Puppet::Rails::InventoryFact.all.map{|f| [f.name,f.value]}.should =~ [["uptime_days","60"],["kernel","Darwin"]]
     end
 
-    it "should remove the previous facts for an existing host" do
+    it "should remove the previous facts for an existing node" do
       Puppet::Node::Facts.new("foo", "uptime_days" => "30", "kernel" => "Darwin").save
       bar_facts = Puppet::Node::Facts.new("bar", "uptime_days" => "35", "kernel" => "Linux")
       foo_facts = Puppet::Node::Facts.new("foo", "uptime_days" => "60", "is_virtual" => "false")
@@ -81,12 +81,12 @@ describe "Puppet::Node::Facts::InventoryActiveRecord", :if => (Puppet.features.r
       @bar_facts.save
     end
 
-    it "should identify facts by host name" do
+    it "should identify facts by node name" do
       Puppet::Node::Facts.find("foo").should == @foo_facts
     end
 
-    it "should return nil if no host instance can be found" do
-      Puppet::Node::Facts.find("non-existent host").should == nil
+    it "should return nil if no node instance can be found" do
+      Puppet::Node::Facts.find("non-existent node").should == nil
     end
 
     it "should convert all single-member arrays into non-arrays" do
-- 
cgit 


From 531e25836e1313cd508ab8394e16cf438a62ac7b Mon Sep 17 00:00:00 2001
From: Nick Lewis <nick@puppetlabs.com>
Date: Wed, 9 Mar 2011 12:55:52 -0800
Subject: maint: Remove serialization of InventoryFact values

This is not necessary because fact values are always strings, and it wasn't
doing the unnecessary job it was expected to do anyway.
---
 spec/unit/indirector/facts/inventory_active_record_spec.rb | 6 ------
 1 file changed, 6 deletions(-)

(limited to 'spec')

diff --git a/spec/unit/indirector/facts/inventory_active_record_spec.rb b/spec/unit/indirector/facts/inventory_active_record_spec.rb
index ca16606b2..c29e58400 100644
--- a/spec/unit/indirector/facts/inventory_active_record_spec.rb
+++ b/spec/unit/indirector/facts/inventory_active_record_spec.rb
@@ -88,12 +88,6 @@ describe "Puppet::Node::Facts::InventoryActiveRecord", :if => (Puppet.features.r
     it "should return nil if no node instance can be found" do
       Puppet::Node::Facts.find("non-existent node").should == nil
     end
-
-    it "should convert all single-member arrays into non-arrays" do
-      Puppet::Node::Facts.new("array", "fact1" => ["value1"]).save
-
-      Puppet::Node::Facts.find("array").values["fact1"].should == "value1"
-    end
   end
 
   describe "#search" do
-- 
cgit 


From cd5deda8f9eefbe55c63c97c81293d01ca05c110 Mon Sep 17 00:00:00 2001
From: Jesse Wolfe <jes5199@gmail.com>
Date: Wed, 9 Mar 2011 16:00:17 -0800
Subject: (#2645) Adding a less-stubby test to verify the "system" attribute's
 behavior

Paired-with: Jacob Helwig <jacob@puppetlabs.com>
---
 spec/unit/provider/user/user_role_add_spec.rb |  1 +
 spec/unit/provider/user/useradd_spec.rb       | 17 ++++++++++++-----
 2 files changed, 13 insertions(+), 5 deletions(-)

(limited to 'spec')

diff --git a/spec/unit/provider/user/user_role_add_spec.rb b/spec/unit/provider/user/user_role_add_spec.rb
index 9cf649267..f73942389 100644
--- a/spec/unit/provider/user/user_role_add_spec.rb
+++ b/spec/unit/provider/user/user_role_add_spec.rb
@@ -115,6 +115,7 @@ describe provider_class do
   describe "when allow duplicate is enabled" do
     before do
       @resource.expects(:allowdupe?).returns true
+      @resource.stubs(:system?)
       @provider.stubs(:is_role?).returns(false)
       @provider.stubs(:execute)
       @provider.expects(:execute).with { |args| args.include?("-o") }
diff --git a/spec/unit/provider/user/useradd_spec.rb b/spec/unit/provider/user/useradd_spec.rb
index 81ad7d400..fd75c43f3 100755
--- a/spec/unit/provider/user/useradd_spec.rb
+++ b/spec/unit/provider/user/useradd_spec.rb
@@ -132,11 +132,6 @@ describe provider_class do
       @provider.addcmd
     end
 
-    it "should check and add if it's a system user" do
-      @provider.expects(:check_system_users).returns([])
-      @provider.addcmd
-    end
-
     it "should check and add if home is managed" do
       @provider.expects(:check_manage_home).returns([])
       @provider.addcmd
@@ -147,6 +142,18 @@ describe provider_class do
       @provider.addcmd
     end
 
+    it "should return an array with -r if system? is true" do
+      resource = Puppet::Type.type(:user).new( :name => "bob", :system => true)
+
+      provider_class.new( resource ).addcmd.should include("-r")
+    end
+
+    it "should return an array without -r if system? is false" do
+      resource = Puppet::Type.type(:user).new( :name => "bob", :system => false)
+
+      provider_class.new( resource ).addcmd.should_not include("-r")
+    end
+
     it "should return an array with full command" do
       @provider.stubs(:command).with(:add).returns("useradd")
       @provider.stubs(:add_properties).returns(["-G", "somegroup"])
-- 
cgit 


From 285c4cc4b056b9c4990738c3d479d1a8993cf959 Mon Sep 17 00:00:00 2001
From: Matt Robinson <matt@puppetlabs.com>
Date: Wed, 9 Mar 2011 16:17:17 -0800
Subject: (#5392) Give a better error when realizing a non-existant resource

You can reproduce the error with a simple manifest

    Bogus_type <| title == 'foo' |>

We used to fail because find_resource_type returned nil and we never
checked if it was nil before calling methods on it.

Reviewed-by: Max Martin <max@puppetlabs.com>
---
 spec/unit/parser/ast/collection_spec.rb | 28 ++++++++++++++++------------
 1 file changed, 16 insertions(+), 12 deletions(-)

(limited to 'spec')

diff --git a/spec/unit/parser/ast/collection_spec.rb b/spec/unit/parser/ast/collection_spec.rb
index 392a2c0f0..cc33075b7 100755
--- a/spec/unit/parser/ast/collection_spec.rb
+++ b/spec/unit/parser/ast/collection_spec.rb
@@ -4,20 +4,21 @@ require File.dirname(__FILE__) + '/../../../spec_helper'
 
 describe Puppet::Parser::AST::Collection do
   before :each do
-    @scope = stub_everything 'scope'
-    @mytype = stub_everything('mytype')
-    @scope.stubs(:find_resource_type).returns @mytype
-    @compiler = stub_everything 'compile'
-    @scope.stubs(:compiler).returns(@compiler)
+    @mytype = Puppet::Resource::Type.new(:definition, "mytype")
+    @environment = Puppet::Node::Environment.new
+    @environment.known_resource_types.add @mytype
+
+    @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("foonode", :environment => @environment))
+    @scope = Puppet::Parser::Scope.new(:compiler => @compiler)
 
     @overrides = stub_everything 'overrides'
     @overrides.stubs(:is_a?).with(Puppet::Parser::AST).returns(true)
-
   end
 
   it "should evaluate its query" do
     query = mock 'query'
     collection = Puppet::Parser::AST::Collection.new :query => query, :form => :virtual
+    collection.type = 'mytype'
 
     query.expects(:safeevaluate).with(@scope)
 
@@ -26,8 +27,8 @@ describe Puppet::Parser::AST::Collection do
 
   it "should instantiate a Collector for this type" do
     collection = Puppet::Parser::AST::Collection.new :form => :virtual, :type => "test"
-    @test_type = stub 'type', :name => 'test'
-    @scope.expects(:find_resource_type).with('test').returns @test_type
+    @test_type = Puppet::Resource::Type.new(:definition, "test")
+    @environment.known_resource_types.add @test_type
 
     Puppet::Parser::Collector.expects(:new).with(@scope, "test", nil, nil, :virtual)
 
@@ -35,7 +36,7 @@ describe Puppet::Parser::AST::Collection do
   end
 
   it "should tell the compiler about this collector" do
-    collection = Puppet::Parser::AST::Collection.new :form => :virtual, :type => "test"
+    collection = Puppet::Parser::AST::Collection.new :form => :virtual, :type => "mytype"
     Puppet::Parser::Collector.stubs(:new).returns("whatever")
 
     @compiler.expects(:add_collection).with("whatever")
@@ -45,7 +46,7 @@ describe Puppet::Parser::AST::Collection do
 
   it "should evaluate overriden paramaters" do
     collector = stub_everything 'collector'
-    collection = Puppet::Parser::AST::Collection.new :form => :virtual, :type => "test", :override => @overrides
+    collection = Puppet::Parser::AST::Collection.new :form => :virtual, :type => "mytype", :override => @overrides
     Puppet::Parser::Collector.stubs(:new).returns(collector)
 
     @overrides.expects(:safeevaluate).with(@scope)
@@ -55,7 +56,7 @@ describe Puppet::Parser::AST::Collection do
 
   it "should tell the collector about overrides" do
     collector = mock 'collector'
-    collection = Puppet::Parser::AST::Collection.new :form => :virtual, :type => "test", :override => @overrides
+    collection = Puppet::Parser::AST::Collection.new :form => :virtual, :type => "mytype", :override => @overrides
     Puppet::Parser::Collector.stubs(:new).returns(collector)
 
     collector.expects(:add_override)
@@ -63,5 +64,8 @@ describe Puppet::Parser::AST::Collection do
     collection.evaluate(@scope)
   end
 
-
+  it "should fail when evaluating undefined resource types" do
+    collection = Puppet::Parser::AST::Collection.new :form => :virtual, :type => "bogus"
+    lambda { collection.evaluate(@scope) }.should raise_error "Resource type bogus doesn't exist"
+  end
 end
-- 
cgit 


From 8858e40839bd693420ddc791df6b51de79356d2a Mon Sep 17 00:00:00 2001
From: Nick Lewis <nick@puppetlabs.com>
Date: Fri, 11 Mar 2011 15:22:23 -0800
Subject: (#6689) Make inventory_active_record terminus search quickly

This terminus behaves the same on all supported DB platforms, by performing a
limited portion of its query in SQL, and the rest of the comparison in Ruby.
Its results are consistent with the YAML terminus.

Paired-With: Jesse Wolfe
---
 spec/unit/indirector/facts/inventory_active_record_spec.rb | 3 ---
 1 file changed, 3 deletions(-)

(limited to 'spec')

diff --git a/spec/unit/indirector/facts/inventory_active_record_spec.rb b/spec/unit/indirector/facts/inventory_active_record_spec.rb
index c29e58400..9558abde2 100644
--- a/spec/unit/indirector/facts/inventory_active_record_spec.rb
+++ b/spec/unit/indirector/facts/inventory_active_record_spec.rb
@@ -68,9 +68,6 @@ describe "Puppet::Node::Facts::InventoryActiveRecord", :if => (Puppet.features.r
       Puppet::Node::Facts.find("foo").should == foo_facts
       Puppet::Rails::InventoryFact.all.map{|f| [f.name,f.value]}.should_not include(["uptime_days", "30"], ["kernel", "Darwin"])
     end
-
-    it "should not replace the node's facts if something goes wrong" do
-    end
   end
 
   describe "#find" do
-- 
cgit 


From ff9e2425a58bb2b1ab836e440c3344b4012623c5 Mon Sep 17 00:00:00 2001
From: Jacob Helwig <jacob@puppetlabs.com>
Date: Fri, 25 Feb 2011 17:03:56 -0800
Subject: (#5428) More fully "stub" Puppet::Resource::Reference for use with
 storedconfigs

The Puppet::Resource::Reference class wasn't stubbing enough of the 0.25.x
behavior to satisfy the needs of storedconfigs.  Since P::R::Reference,
and Puppet::Resource were merged as part of 2.6.x, we can pretend that
P::Resource is P::R::Reference for the purposes of loading data from
storedconfigs.  This should still satisfy the over-the-wire serialization
needs of 0.25.x.

This also changes internal references to @parameters in
Puppet::Resource(::Reference) to go through a parameters method.  This
allows us to "initialize" this instance variable lazily, since loading via
YAML bypasses the normal initialize method.

Paired-with: Daniel Pittman <daniel@puppetlabs.com>
Reviewed-by: Markus Roberts <markus@puppetlabs.com>
---
 spec/unit/resource_spec.rb | 26 ++++++++++++++++++++++++--
 1 file changed, 24 insertions(+), 2 deletions(-)

(limited to 'spec')

diff --git a/spec/unit/resource_spec.rb b/spec/unit/resource_spec.rb
index ff31b2492..4c1dc4952 100755
--- a/spec/unit/resource_spec.rb
+++ b/spec/unit/resource_spec.rb
@@ -99,11 +99,11 @@ describe Puppet::Resource do
   end
 
   it 'should fail if strict is set and type does not exist' do
-    lambda { Puppet::Resource.new('foo', 'title', {:strict=>true}) }.should raise_error(ArgumentError, 'Invalid resource type foo') 
+    lambda { Puppet::Resource.new('foo', 'title', {:strict=>true}) }.should raise_error(ArgumentError, 'Invalid resource type foo')
   end
 
   it 'should fail if strict is set and class does not exist' do
-    lambda { Puppet::Resource.new('Class', 'foo', {:strict=>true}) }.should raise_error(ArgumentError, 'Could not find declared class foo') 
+    lambda { Puppet::Resource.new('Class', 'foo', {:strict=>true}) }.should raise_error(ArgumentError, 'Could not find declared class foo')
   end
 
   it "should fail if the title is a hash and the type is not a valid resource reference string" do
@@ -463,6 +463,28 @@ describe Puppet::Resource do
     end
   end
 
+  describe "when loading 0.25.x storedconfigs YAML" do
+    before :each do
+      @old_storedconfig_yaml = %q{--- !ruby/object:Puppet::Resource::Reference
+builtin_type:
+title: /tmp/bar
+type: File
+}
+    end
+
+    it "should deserialize a Puppet::Resource::Reference without exceptions" do
+      lambda { YAML.load(@old_storedconfig_yaml) }.should_not raise_error
+    end
+
+    it "should deserialize as a Puppet::Resource::Reference as a Puppet::Resource" do
+      YAML.load(@old_storedconfig_yaml).class.should == Puppet::Resource
+    end
+
+    it "should to_hash properly" do
+      YAML.load(@old_storedconfig_yaml).to_hash.should == { :path => "/tmp/bar" }
+    end
+  end
+
   describe "when converting to a RAL resource" do
     it "should use the resource type's :new method to create the resource if the resource is of a builtin type" do
       resource = Puppet::Resource.new("file", @basepath+"/my/file")
-- 
cgit 


From 25926d1922a9b75bc87ed7feed30693a69cdea9a Mon Sep 17 00:00:00 2001
From: Max Martin <max@puppetlabs.com>
Date: Tue, 15 Mar 2011 15:52:37 -0700
Subject: (#6723) Fix withenv environment restoration bug

Ensured that withenv properly restores the environment after it runs a block and added testing for the method.

Reviewed-by: Matt Robinson and Daniel Pittman
---
 spec/unit/util/execution_spec.rb | 49 ++++++++++++++++++++++++++++++++++++++++
 1 file changed, 49 insertions(+)
 create mode 100644 spec/unit/util/execution_spec.rb

(limited to 'spec')

diff --git a/spec/unit/util/execution_spec.rb b/spec/unit/util/execution_spec.rb
new file mode 100644
index 000000000..312dd3b8e
--- /dev/null
+++ b/spec/unit/util/execution_spec.rb
@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Puppet::Util::Execution do
+  include Puppet::Util::Execution
+  describe "#withenv" do
+    before :each do
+      @original_path = ENV["PATH"]
+      @new_env = {:PATH => "/some/bogus/path"}
+    end
+
+    it "should change environment variables within the block then reset environment variables to their original values" do
+      withenv @new_env do
+        ENV["PATH"].should == "/some/bogus/path"
+      end
+      ENV["PATH"].should == @original_path
+    end
+
+    it "should reset environment variables to their original values even if the block fails" do
+      begin
+        withenv @new_env do
+          ENV["PATH"].should == "/some/bogus/path"
+          raise "This is a failure"
+        end
+      rescue
+      end
+      ENV["PATH"].should == @original_path
+    end
+
+    it "should reset environment variables even when they are set twice" do
+      # Setting Path & Environment parameters in Exec type can cause weirdness
+      @new_env["PATH"] = "/someother/bogus/path"
+      withenv @new_env do
+        # When assigning duplicate keys, can't guarantee order of evaluation
+        ENV["PATH"].should =~ /\/some.*\/bogus\/path/
+      end
+      ENV["PATH"].should == @original_path
+    end
+
+    it "should remove any new environment variables after the block ends" do
+      @new_env[:FOO] = "bar"
+      withenv @new_env do
+        ENV["FOO"].should == "bar"
+      end
+      ENV["FOO"].should == nil
+    end
+  end
+end
-- 
cgit 


From 9781032736a34f577241828bcf812a648b4f42e9 Mon Sep 17 00:00:00 2001
From: Jesse Wolfe <jes5199@gmail.com>
Date: Tue, 15 Mar 2011 17:28:52 -0700
Subject: Revert "Merge branch 'ticket/2.6.x/5605' of
 git://github.com/stschulte/puppet into 2.6.next"

This reverts commit 658bdb72bee3ad664627a71793213e6540afd5cb, reversing
changes made to 4c9bd43bc2f5fde9d86196e8689dced929d39aad.

See comment at http://projects.puppetlabs.com/issues/5605#note-9
---
 spec/unit/resource_spec.rb | 11 ++---------
 1 file changed, 2 insertions(+), 9 deletions(-)

(limited to 'spec')

diff --git a/spec/unit/resource_spec.rb b/spec/unit/resource_spec.rb
index 6f94409ab..345ccd06e 100755
--- a/spec/unit/resource_spec.rb
+++ b/spec/unit/resource_spec.rb
@@ -276,7 +276,7 @@ describe Puppet::Resource do
   describe "when referring to a resource with name canonicalization" do
     it "should canonicalize its own name" do
       res = Puppet::Resource.new("file", "/path/")
-      res.uniqueness_key.should == "/path"
+      res.uniqueness_key.should == ["/path"]
       res.ref.should == "File[/path/]"
     end
   end
@@ -800,14 +800,7 @@ type: File
   end
 
   describe "when generating the uniqueness key" do
-
-    it "should use namevar if there is only one key_attribute" do
-      Puppet::Type.type(:file).stubs(:key_attributes).returns [:path]
-      res = Puppet::Resource.new("file", "/my/file", :parameters => {:owner => 'root', :content => 'hello'})
-      res.uniqueness_key.should == '/my/file'
-    end
-
-    it "should include all of the key_attributes" do
+    it "should include all of the key_attributes in alphabetical order by attribute name" do
       Puppet::Type.type(:file).stubs(:key_attributes).returns [:myvar, :owner, :path]
       Puppet::Type.type(:file).stubs(:title_patterns).returns(
         [ [ /(.*)/, [ [:path, lambda{|x| x} ] ] ] ]
-- 
cgit 


From 4f34dbf206e591614c2fc06ce9bed1628ee85715 Mon Sep 17 00:00:00 2001
From: Jesse Wolfe <jes5199@gmail.com>
Date: Tue, 15 Mar 2011 15:29:01 -0700
Subject: Fix #5610: Prevent unnecessary RAL lookups

Reviewed-By: Paul Berry <paul@puppetlabs.com>
---
 spec/unit/type_spec.rb | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

(limited to 'spec')

diff --git a/spec/unit/type_spec.rb b/spec/unit/type_spec.rb
index b7a08977e..6d9d0b234 100755
--- a/spec/unit/type_spec.rb
+++ b/spec/unit/type_spec.rb
@@ -434,7 +434,7 @@ describe Puppet::Type do
         patterns.length.should == 1
         patterns[0].length.should == 2
       end
-      
+
       it "should have a regexp that captures the entire string" do
         patterns = @type_class.title_patterns
         string = "abc\n\tdef"
@@ -570,4 +570,15 @@ describe Puppet::Type.metaparamclass(:audit) do
     @resource[:audit] = :noop
     @resource.parameter(:noop).should be_nil
   end
+
+  describe "when generating the uniqueness key" do
+    it "should include all of the key_attributes in alphabetical order by attribute name" do
+      Puppet::Type.type(:file).stubs(:key_attributes).returns [:path, :mode, :owner]
+      Puppet::Type.type(:file).stubs(:title_patterns).returns(
+        [ [ /(.*)/, [ [:path, lambda{|x| x} ] ] ] ]
+      )
+      res = Puppet::Type.type(:file).new( :title => '/my/file', :path => '/my/file', :owner => 'root', :content => 'hello' )
+      res.uniqueness_key.should == [ nil, 'root', '/my/file']
+    end
+  end
 end
-- 
cgit 


From 852fb9744320c253772c85e52b262b0290fb7dd4 Mon Sep 17 00:00:00 2001
From: Matt Robinson <matt@puppetlabs.com>
Date: Tue, 15 Mar 2011 16:13:15 -0700
Subject: (#5073) Download plugins even if you're filtering on tags

When we eval a resource in transaction.rb it was being skipped when
filtering on tags and downloading the plugins.  There's a lot of
complicated conditions for whether to skip a resource, but this is a
condensed version of the path that was causing plugins not to be
downloaded.

  skip?
    missing_tags?
      !ignore_tags?
        !host_config

The Puppet::Configurer::Downloader creates separate catalogs and applies them
to get custom facts and plugins, so should be setting host_config to false.
Puppet::Util::Settings also sets host_config to false when you call use on
settings, while normal catalog application defaults to true.

Thanks to Stefan Schulte <stefan.schulte@taunusstein.net> for suggesting
the implementation fix.
---
 spec/unit/configurer/downloader_spec.rb | 32 ++++++++++++++++++++++----------
 1 file changed, 22 insertions(+), 10 deletions(-)

(limited to 'spec')

diff --git a/spec/unit/configurer/downloader_spec.rb b/spec/unit/configurer/downloader_spec.rb
index c57f39fb5..4080263e7 100755
--- a/spec/unit/configurer/downloader_spec.rb
+++ b/spec/unit/configurer/downloader_spec.rb
@@ -5,6 +5,8 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 require 'puppet/configurer/downloader'
 
 describe Puppet::Configurer::Downloader do
+  require 'puppet_spec/files'
+  include PuppetSpec::Files
   it "should require a name" do
     lambda { Puppet::Configurer::Downloader.new }.should raise_error(ArgumentError)
   end
@@ -96,25 +98,35 @@ describe Puppet::Configurer::Downloader do
 
   describe "when creating the catalog to do the downloading" do
     before do
-      @dler = Puppet::Configurer::Downloader.new("foo", "path", "source")
+      @dler = Puppet::Configurer::Downloader.new("foo", "/download/path", "source")
     end
 
     it "should create a catalog and add the file to it" do
-      file = mock 'file'
-      catalog = mock 'catalog'
-
-      @dler.expects(:file).returns file
-
-      Puppet::Resource::Catalog.expects(:new).returns catalog
-      catalog.expects(:add_resource).with(file)
+      catalog = @dler.catalog
+      catalog.resources.size.should == 1
+      catalog.resources.first.class.should == Puppet::Type::File
+      catalog.resources.first.name.should == "/download/path"
+    end
 
-      @dler.catalog.should equal(catalog)
+    it "should specify that it is not managing a host catalog" do
+      @dler.catalog.host_config.should == false
     end
+
   end
 
   describe "when downloading" do
     before do
-      @dler = Puppet::Configurer::Downloader.new("foo", "path", "source")
+      @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)
+    end
+
+    it "should not skip downloaded resources when filtering on tags" do
+      Puppet[:tags] = 'maytag'
+      @dler.evaluate
+
+      File.exists?(@dl_name).should be_true
     end
 
     it "should log that it is downloading" do
-- 
cgit