puppet 2.7.9 → 2.7.11

data/spec/unit/provider/service/smf_spec.rb

@@ -92,7 +92,7 @@ describe provider_class do
 
     it "should always execute external command 'svcadm enable /system/myservice'" do
       @provider.stubs(:status).returns :running
-      @provider.expects(:texecute).with(:start, ["/usr/sbin/svcadm", :enable, "/system/myservice"], true)
+      @provider.expects(:texecute).with(:start, ["/usr/sbin/svcadm", :enable, "-s", "/system/myservice"], true)
       @provider.start
     end
 
@@ -112,7 +112,7 @@ describe provider_class do
 
     it "should import the manifest if service is missing" do
       @provider.expects(:svccfg).with(:import, "/tmp/myservice.xml")
-      @provider.expects(:texecute).with(:start, ["/usr/sbin/svcadm", :enable, "/system/myservice"], true)
+      @provider.expects(:texecute).with(:start, ["/usr/sbin/svcadm", :enable, "-s", "/system/myservice"], true)
       @provider.expects(:svcs).with('-H', '-o', 'state,nstate', "/system/myservice").returns("online\t-")
       @provider.start
     end
@@ -125,7 +125,7 @@ describe provider_class do
 
   describe "when stopping" do
     it "should execute external command 'svcadm disable /system/myservice'" do
-      @provider.expects(:texecute).with(:stop, ["/usr/sbin/svcadm", :disable, "/system/myservice"], true)
+      @provider.expects(:texecute).with(:stop, ["/usr/sbin/svcadm", :disable, "-s", "/system/myservice"], true)
       @provider.stop
     end
   end

data/spec/unit/provider/user/pw_spec.rb

@@ -0,0 +1,183 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+
+provider_class = Puppet::Type.type(:user).provider(:pw)
+
+describe provider_class do
+  let :resource do
+    Puppet::Type.type(:user).new(:name => "testuser", :provider => :pw)
+  end
+
+  describe "when creating users" do
+    let :provider do
+      prov = resource.provider
+      prov.expects(:exists?).returns nil
+      prov
+    end
+
+    it "should run pw with no additional flags when no properties are given" do
+      provider.addcmd.must == [provider_class.command(:pw), "useradd", "testuser"]
+      provider.expects(:execute).with([provider_class.command(:pw), "useradd", "testuser"])
+      provider.create
+    end
+
+    it "should use -o when allowdupe is enabled" do
+      resource[:allowdupe] = true
+      provider.expects(:execute).with(includes("-o"))
+      provider.create
+    end
+
+    it "should use -c with the correct argument when the comment property is set" do
+      resource[:comment] = "Testuser Name"
+      provider.expects(:execute).with(all_of(includes("-c"), includes("Testuser Name")))
+      provider.create
+    end
+
+    it "should use -e with the correct argument when the expiry property is set" do
+      resource[:expiry] = "2010-02-19"
+      provider.expects(:execute).with(all_of(includes("-e"), includes("19-02-2010")))
+      provider.create
+    end
+
+    it "should use -g with the correct argument when the gid property is set" do
+      resource[:gid] = 12345
+      provider.expects(:execute).with(all_of(includes("-g"), includes(12345)))
+      provider.create
+    end
+
+    it "should use -G with the correct argument when the groups property is set" do
+      resource[:groups] = "group1"
+      provider.expects(:execute).with(all_of(includes("-G"), includes("group1")))
+      provider.create
+    end
+
+    it "should use -G with all the given groups when the groups property is set to an array" do
+      resource[:groups] = ["group1", "group2"]
+      provider.expects(:execute).with(all_of(includes("-G"), includes("group1,group2")))
+      provider.create
+    end
+
+    it "should use -d with the correct argument when the home property is set" do
+      resource[:home] = "/home/testuser"
+      provider.expects(:execute).with(all_of(includes("-d"), includes("/home/testuser")))
+      provider.create
+    end
+
+    it "should use -m when the managehome property is enabled" do
+      resource[:managehome] = true
+      provider.expects(:execute).with(includes("-m"))
+      provider.create
+    end
+
+    it "should call the password set function with the correct argument when the password property is set" do
+      resource[:password] = "*"
+      provider.expects(:execute)
+      provider.expects(:password=).with("*")
+      provider.create
+    end
+
+    it "should use -s with the correct argument when the shell property is set" do
+      resource[:shell] = "/bin/sh"
+      provider.expects(:execute).with(all_of(includes("-s"), includes("/bin/sh")))
+      provider.create
+    end
+
+    it "should use -u with the correct argument when the uid property is set" do
+      resource[:uid] = 12345
+      provider.expects(:execute).with(all_of(includes("-u"), includes(12345)))
+      provider.create
+    end
+
+    # (#7500) -p should not be used to set a password (it means something else)
+    it "should not use -p when a password is given" do
+      resource[:password] = "*"
+      provider.addcmd.should_not include("-p")
+      provider.expects(:password=)
+      provider.expects(:execute).with(Not(includes("-p")))
+      provider.create
+    end
+  end
+
+  describe "when deleting users" do
+    it "should run pw with no additional flags" do
+      provider = resource.provider
+      provider.expects(:exists?).returns true
+      provider.deletecmd.must == [provider_class.command(:pw), "userdel", "testuser"]
+      provider.expects(:execute).with([provider_class.command(:pw), "userdel", "testuser"])
+      provider.delete
+    end
+  end
+
+  describe "when modifying users" do
+    let :provider do
+      resource.provider
+    end
+
+    it "should run pw with the correct arguments" do
+      provider.modifycmd("uid", 12345).must == [provider_class.command(:pw), "usermod", "testuser", "-u", 12345]
+      provider.expects(:execute).with([provider_class.command(:pw), "usermod", "testuser", "-u", 12345])
+      provider.uid = 12345
+    end
+
+    it "should use -c with the correct argument when the comment property is changed" do
+      resource[:comment] = "Testuser Name"
+      provider.expects(:execute).with(all_of(includes("-c"), includes("Testuser New Name")))
+      provider.comment = "Testuser New Name"
+    end
+
+    it "should use -e with the correct argument when the expiry property is changed" do
+      resource[:expiry] = "2010-02-19"
+      provider.expects(:execute).with(all_of(includes("-e"), includes("19-02-2011")))
+      provider.expiry = "2011-02-19"
+    end
+
+    it "should use -g with the correct argument when the gid property is changed" do
+      resource[:gid] = 12345
+      provider.expects(:execute).with(all_of(includes("-g"), includes(54321)))
+      provider.gid = 54321
+    end
+
+    it "should use -G with the correct argument when the groups property is changed" do
+      resource[:groups] = "group1"
+      provider.expects(:execute).with(all_of(includes("-G"), includes("group2")))
+      provider.groups = "group2"
+    end
+
+    it "should use -G with all the given groups when the groups property is changed with an array" do
+      resource[:groups] = ["group1", "group2"]
+      provider.expects(:execute).with(all_of(includes("-G"), includes("group3,group4")))
+      provider.groups = "group3,group4"
+    end
+
+    it "should use -d with the correct argument when the home property is changed" do
+      resource[:home] = "/home/testuser"
+      provider.expects(:execute).with(all_of(includes("-d"), includes("/newhome/testuser")))
+      provider.home = "/newhome/testuser"
+    end
+
+    it "should use -m and -d with the correct argument when the home property is changed and managehome is enabled" do
+      resource[:home] = "/home/testuser"
+      resource[:managehome] = true
+      provider.expects(:execute).with(all_of(includes("-d"), includes("/newhome/testuser"), includes("-m")))
+      provider.home = "/newhome/testuser"
+    end
+
+    it "should call the password set function with the correct argument when the password property is changed" do
+      resource[:password] = "*"
+      provider.expects(:password=).with("!")
+      provider.password = "!"
+    end
+
+    it "should use -s with the correct argument when the shell property is changed" do
+      resource[:shell] = "/bin/sh"
+      provider.expects(:execute).with(all_of(includes("-s"), includes("/bin/tcsh")))
+      provider.shell = "/bin/tcsh"
+    end
+
+    it "should use -u with the correct argument when the uid property is changed" do
+      resource[:uid] = 12345
+      provider.expects(:execute).with(all_of(includes("-u"), includes(54321)))
+      provider.uid = 54321
+    end
+  end
+end

data/spec/unit/provider/user/user_role_add_spec.rb

@@ -1,10 +1,10 @@
-#!/usr/bin/env rspec
 require 'spec_helper'
 require 'puppet_spec/files'
+require 'tempfile'
 
 provider_class = Puppet::Type.type(:user).provider(:user_role_add)
 
-describe provider_class do
+describe provider_class, :unless => Puppet.features.microsoft_windows? do
   include PuppetSpec::Files
 
   before do
@@ -246,44 +246,51 @@ describe provider_class do
   end
 
   describe "when setting the password" do
-    before :each do
-      @shadow_file = tmpfile('shadow')
-      File.open(@shadow_file, 'w') do |f|
-        f.puts 'fakeval:password:0'
-      end
-      @provider.stubs(:shadow_file).returns(@shadow_file)
-    end
-
-    it 'opens #shadow_file for reading' do
-      File.expects(:open).with(@shadow_file, "r")
-      File.stubs(:rename)
-
-      @provider.password = "hashedpassword"
-    end
-
-    it 'writes to "#{shadow_file}_tmp"' do
-      File.stubs(:rename)
-      File.stubs(:unlink)
-      @provider.password = 'hashedpassword'
-
-      File.read("#{@shadow_file}_tmp").should =~ /hashedpassword/
-    end
-
-    it 'renames "#{shadow_file}_tmp" to shadow_file' do
-      File.stubs(:open)
-      File.expects(:rename).with("#{@shadow_file}_tmp", @shadow_file)
-
-      @provider.password = "hashedpassword"
-    end
+    let(:path) { tmpfile('etc-shadow') }
 
-    it 'updates the last changed field' do
-      Time.stubs(:now).returns(42 * 86400)
-
-      File.read(@shadow_file).should == "fakeval:password:0\n"
-
-      @provider.password = 'hashedpassword'
-
-      File.read(@shadow_file).should == "fakeval:hashedpassword:42"
+    before :each do
+      @provider.stubs(:target_file_path).returns(path)
+    end
+
+    def write_fixture(content)
+      File.open(path, 'w') { |f| f.print(content) }
+    end
+
+    it "should update the target user" do
+      write_fixture <<FIXTURE
+fakeval:seriously:15315:0:99999:7:::
+FIXTURE
+      @provider.password = "totally"
+      File.read(path).should =~ /^fakeval:totally:/
+    end
+
+    it "should only update the target user" do
+      write_fixture <<FIXTURE
+before:seriously:15315:0:99999:7:::
+fakeval:seriously:15315:0:99999:7:::
+fakevalish:seriously:15315:0:99999:7:::
+after:seriously:15315:0:99999:7:::
+FIXTURE
+      @provider.password = "totally"
+      File.read(path).should == <<EOT
+before:seriously:15315:0:99999:7:::
+fakeval:totally:15315:0:99999:7:::
+fakevalish:seriously:15315:0:99999:7:::
+after:seriously:15315:0:99999:7:::
+EOT
+    end
+
+    # This preserves the current semantics, but is it right? --daniel 2012-02-05
+    it "should do nothing if the target user is missing" do
+      fixture = <<FIXTURE
+before:seriously:15315:0:99999:7:::
+fakevalish:seriously:15315:0:99999:7:::
+after:seriously:15315:0:99999:7:::
+FIXTURE
+
+      write_fixture fixture
+      @provider.password = "totally"
+      File.read(path).should == fixture
     end
   end
 

data/spec/unit/provider/user/windows_adsi_spec.rb

@@ -74,6 +74,7 @@ describe Puppet::Type.type(:user).provider(:windows_adsi) do
       user.stubs(:groups).returns(['group2', 'group3'])
 
       create = sequence('create')
+      user.expects(:password=).in_sequence(create)
       user.expects(:commit).in_sequence(create)
       user.expects(:set_groups).with('group1,group2', false).in_sequence(create)
       user.expects(:[]=).with('Description', 'a test user')

data/spec/unit/provider_spec.rb

@@ -27,4 +27,36 @@ describe Puppet::Provider do
 
     two.specificity.should > one.specificity
   end
+
+  it "should be Comparable" do
+    res = Puppet::Type.type(:notify).new(:name => "res")
+
+    # Normally I wouldn't like the stubs, but the only way to name a class
+    # otherwise is to assign it to a constant, and that hurts more here in
+    # testing world. --daniel 2012-01-29
+    a = Class.new(Puppet::Provider).new(res)
+    a.class.stubs(:name).returns "Puppet::Provider::Notify::A"
+
+    b = Class.new(Puppet::Provider).new(res)
+    b.class.stubs(:name).returns "Puppet::Provider::Notify::B"
+
+    c = Class.new(Puppet::Provider).new(res)
+    c.class.stubs(:name).returns "Puppet::Provider::Notify::C"
+
+    [[a, b, c], [a, c, b], [b, a, c], [b, c, a], [c, a, b], [c, b, a]].each do |this|
+      this.sort.should == [a, b, c]
+    end
+
+    a.should be < b
+    a.should be < c
+    b.should be > a
+    b.should be < c
+    c.should be > a
+    c.should be > b
+
+    [a, b, c].each {|x| a.should be <= x }
+    [a, b, c].each {|x| c.should be >= x }
+
+    b.should be_between(a, c)
+  end
 end

data/spec/unit/reports/store_spec.rb

@@ -3,6 +3,9 @@ require 'spec_helper'
 
 require 'puppet/reports'
 require 'time'
+require 'pathname'
+require 'tempfile'
+require 'fileutils'
 
 processor = Puppet::Reports.report(:store)
 
@@ -10,7 +13,7 @@ describe processor do
   describe "#process" do
     include PuppetSpec::Files
     before :each do
-      Puppet[:reportdir] = tmpdir('reports') << '/reports' 
+      Puppet[:reportdir] = File.join(tmpdir('reports'), 'reports')
       @report = YAML.load_file(File.join(PuppetSpec::FIXTURE_DIR, 'yaml/report2.6.x.yaml')).extend processor
     end
 
@@ -26,5 +29,20 @@ describe processor do
 
       File.read(File.join(Puppet[:reportdir], @report.host, "201101061200.yaml")).should == @report.to_yaml
     end
+
+    it "should write to the report directory in the correct sequence" do
+      # By doing things in this sequence we should protect against race
+      # conditions
+      Time.stubs(:now).returns(Time.parse("2011-01-06 12:00:00 UTC"))
+      writeseq = sequence("write")
+      file = mock "file"
+      Tempfile.expects(:new).in_sequence(writeseq).returns(file)
+      file.expects(:chmod).in_sequence(writeseq).with(0640)
+      file.expects(:print).with(@report.to_yaml).in_sequence(writeseq)
+      file.expects(:close).in_sequence(writeseq)
+      file.stubs(:path).returns(File.join(Dir.tmpdir, "foo123"))
+      FileUtils.expects(:mv).in_sequence(writeseq).with(File.join(Dir.tmpdir, "foo123"), File.join(Puppet[:reportdir], @report.host, "201101061200.yaml"))
+      @report.process
+    end
   end
 end

data/spec/unit/simple_graph_spec.rb

@@ -268,9 +268,24 @@ describe Puppet::SimpleGraph do
       @graph = Puppet::SimpleGraph.new
     end
 
+    # This works with `add_edges` to auto-vivify the resource instances.
+    let :vertex do
+      Hash.new do |hash, key|
+        hash[key] = Puppet::Type.type(:notify).new(:name => key.to_s)
+      end
+    end
+
     def add_edges(hash)
       hash.each do |a,b|
-        @graph.add_edge(a, b)
+        @graph.add_edge(vertex[a], vertex[b])
+      end
+    end
+
+    def simplify(cycles)
+      cycles.map do |x|
+        x.map do |y|
+          y.to_s.match(/^Notify\[(.*)\]$/)[1]
+        end
       end
     end
 
@@ -298,7 +313,7 @@ describe Puppet::SimpleGraph do
       add_edges :a => :b, :b => :a
       # cycle detection starts from a or b randomly
       # so we need to check for either ordering in the error message
-      want = %r{Found 1 dependency cycle:\n\((a => b => a|b => a => b)\)\nTry}
+      want = %r{Found 1 dependency cycle:\n\((Notify\[a\] => Notify\[b\] => Notify\[a\]|Notify\[b\] => Notify\[a\] => Notify\[b\])\)\nTry}
       expect { @graph.report_cycles_in_graph }.to raise_error(Puppet::Error, want)
     end
 
@@ -308,8 +323,8 @@ describe Puppet::SimpleGraph do
       add_edges "b" => "c"
 
       cycles = nil
-      expect { cycles = @graph.find_cycles_in_graph.sort }.should_not raise_error
-      cycles.should be == [["a", "b"]]
+      expect { cycles = @graph.find_cycles_in_graph }.should_not raise_error
+      simplify(cycles).should be == [["a", "b"]]
     end
 
     it "cycle discovery should handle two distinct cycles" do
@@ -317,8 +332,8 @@ describe Puppet::SimpleGraph do
       add_edges "b" => "b1", "b1" => "b"
 
       cycles = nil
-      expect { cycles = @graph.find_cycles_in_graph.sort }.should_not raise_error
-      cycles.should be == [["a", "a1"], ["b", "b1"]]
+      expect { cycles = @graph.find_cycles_in_graph }.should_not raise_error
+      simplify(cycles).should be == [["a1", "a"], ["b1", "b"]]
     end
 
     it "cycle discovery should handle two cycles in a connected graph" do
@@ -327,8 +342,8 @@ describe Puppet::SimpleGraph do
       add_edges "c" => "c1", "c1" => "c2", "c2" => "c3", "c3" => "c"
 
       cycles = nil
-      expect { cycles = @graph.find_cycles_in_graph.sort }.should_not raise_error
-      cycles.should be == [%w{a a1}, %w{c c1 c2 c3}]
+      expect { cycles = @graph.find_cycles_in_graph }.should_not raise_error
+      simplify(cycles).should be == [%w{a1 a}, %w{c1 c2 c3 c}]
     end
 
     it "cycle discovery should handle a complicated cycle" do
@@ -338,8 +353,8 @@ describe Puppet::SimpleGraph do
       add_edges "c" => "c2", "c2" => "b"
 
       cycles = nil
-      expect { cycles = @graph.find_cycles_in_graph.sort }.should_not raise_error
-      cycles.should be == [%w{a b c c1 c2}]
+      expect { cycles = @graph.find_cycles_in_graph }.should_not raise_error
+      simplify(cycles).should be == [%w{a b c1 c2 c}]
     end
 
     it "cycle discovery should not fail with large data sets" do
@@ -347,16 +362,16 @@ describe Puppet::SimpleGraph do
       (1..(limit - 1)).each do |n| add_edges n.to_s => (n+1).to_s end
 
       cycles = nil
-      expect { cycles = @graph.find_cycles_in_graph.sort }.should_not raise_error
-      cycles.should be == []
+      expect { cycles = @graph.find_cycles_in_graph }.should_not raise_error
+      simplify(cycles).should be == []
     end
 
     it "path finding should work with a simple cycle" do
       add_edges "a" => "b", "b" => "c", "c" => "a"
 
-      cycles = @graph.find_cycles_in_graph.sort
+      cycles = @graph.find_cycles_in_graph
       paths = @graph.paths_in_cycle(cycles.first, 100)
-      paths.should be == [%w{a b c a}]
+      simplify(paths).should be == [%w{a b c a}]
     end
 
     it "path finding should work with two independent cycles" do
@@ -364,28 +379,28 @@ describe Puppet::SimpleGraph do
       add_edges "a" => "b2"
       add_edges "b1" => "a", "b2" => "a"
 
-      cycles = @graph.find_cycles_in_graph.sort
+      cycles = @graph.find_cycles_in_graph
       cycles.length.should be == 1
 
       paths = @graph.paths_in_cycle(cycles.first, 100)
-      paths.sort.should be == [%w{a b1 a}, %w{a b2 a}]
+      simplify(paths).should be == [%w{a b1 a}, %w{a b2 a}]
     end
 
     it "path finding should prefer shorter paths in cycles" do
       add_edges "a" => "b", "b" => "c", "c" => "a"
       add_edges "b" => "a"
 
-      cycles = @graph.find_cycles_in_graph.sort
+      cycles = @graph.find_cycles_in_graph
       cycles.length.should be == 1
 
       paths = @graph.paths_in_cycle(cycles.first, 100)
-      paths.should be == [%w{a b a}, %w{a b c a}]
+      simplify(paths).should be == [%w{a b a}, %w{a b c a}]
     end
 
     it "path finding should respect the max_path value" do
       (1..20).each do |n| add_edges "a" => "b#{n}", "b#{n}" => "a" end
 
-      cycles = @graph.find_cycles_in_graph.sort
+      cycles = @graph.find_cycles_in_graph
       cycles.length.should be == 1
 
       (1..20).each do |n|