chef 10.34.6-x86-mingw32 → 11.6.2-x86-mingw32

data/spec/unit/provider/git_spec.rb

@@ -82,7 +82,7 @@ describe Chef::Provider::Git do
   context "resolving revisions to a SHA" do
 
     before do
-      @git_ls_remote = "git ls-remote git://github.com/opscode/chef.git "
+      @git_ls_remote = "git ls-remote \"git://github.com/opscode/chef.git\" "
     end
 
     it "returns resource.revision as is if revision is already a full SHA" do
@@ -91,15 +91,25 @@ describe Chef::Provider::Git do
 
     it "converts resource.revision from a tag to a SHA" do
       @resource.revision "v1.0"
-      @stdout = "503c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/0.8-alpha\n"
-      @provider.should_receive(:shell_out!).with(@git_ls_remote + "v1.0", {:log_tag=>"git[web2.0 app]", :log_level=>:debug}).and_return(mock("ShellOut result", :stdout => @stdout))
+      @stdout = ("d03c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/0.8-alpha\n" +
+                 "503c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/v1.0\n")
+      @provider.should_receive(:shell_out!).with(@git_ls_remote + "v1.0*", {:log_tag=>"git[web2.0 app]"}).and_return(mock("ShellOut result", :stdout => @stdout))
       @provider.target_revision.should eql("503c22a5e41f5ae3193460cca044ed1435029f53")
     end
 
+    it "converts resource.revision from an annotated tag to the tagged SHA (not SHA of tag)" do
+      @resource.revision "v1.0"
+      @stdout = ("d03c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/0.8-alpha\n" +
+                 "503c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/v1.0\n" +
+                 "663c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/v1.0^{}\n")
+      @provider.should_receive(:shell_out!).with(@git_ls_remote + "v1.0*", {:log_tag=>"git[web2.0 app]"}).and_return(mock("ShellOut result", :stdout => @stdout))
+      @provider.target_revision.should eql("663c22a5e41f5ae3193460cca044ed1435029f53")
+    end
+
     it "raises an invalid remote reference error if you try to deploy from ``origin'' and assertions are run" do
       @resource.revision "origin/"
       @provider.action = :checkout
-      @provider.define_resource_requirements 
+      @provider.define_resource_requirements
       ::File.stub!(:directory?).with("/my/deploy").and_return(true)
       lambda {@provider.process_resource_requirements}.should raise_error(Chef::Exceptions::InvalidRemoteGitReference)
     end
@@ -108,7 +118,7 @@ describe Chef::Provider::Git do
       @resource.revision "FAIL, that's the revision I want"
       @provider.action = :checkout
       @provider.should_receive(:shell_out!).and_return(mock("ShellOut result", :stdout => "\n"))
-      @provider.define_resource_requirements 
+      @provider.define_resource_requirements
       lambda { @provider.process_resource_requirements }.should raise_error(Chef::Exceptions::UnresolvableGitReference)
     end
 
@@ -118,13 +128,13 @@ describe Chef::Provider::Git do
       @provider.target_revision.should == nil
     end
 
-    it "does not raise an error when the revision is valid and assertions are run." do 
-      @resource.revision "v1.0"
+    it "does not raise an error when the revision is valid and assertions are run." do
+      @resource.revision "0.8-alpha"
       @stdout = "503c22a5e41f5ae3193460cca044ed1435029f53\trefs/heads/0.8-alpha\n"
-      @provider.should_receive(:shell_out!).with(@git_ls_remote + "v1.0", {:log_tag=>"git[web2.0 app]", :log_level=>:debug}).and_return(mock("ShellOut result", :stdout => @stdout))
+      @provider.should_receive(:shell_out!).with(@git_ls_remote + "0.8-alpha*", {:log_tag=>"git[web2.0 app]"}).and_return(mock("ShellOut result", :stdout => @stdout))
       @provider.action = :checkout
       ::File.stub!(:directory?).with("/my/deploy").and_return(true)
-      @provider.define_resource_requirements 
+      @provider.define_resource_requirements
       lambda { @provider.process_resource_requirements }.should_not raise_error(RuntimeError)
     end
 
@@ -146,7 +156,7 @@ b7d19519a1c15f1c1a324e2683bd728b6198ce5a\trefs/tags/0.7.8^{}
 ebc1b392fe7e8f0fbabc305c299b4d365d2b4d9b\trefs/tags/chef-server-package
 SHAS
       @resource.revision ''
-      @provider.should_receive(:shell_out!).with(@git_ls_remote, {:log_tag=>"git[web2.0 app]", :log_level=>:debug}).and_return(mock("ShellOut result", :stdout => @stdout))
+      @provider.should_receive(:shell_out!).with(@git_ls_remote + "HEAD", {:log_tag=>"git[web2.0 app]"}).and_return(mock("ShellOut result", :stdout => @stdout))
       @provider.target_revision.should eql("28af684d8460ba4793eda3e7ac238c864a5d029a")
     end
   end
@@ -158,9 +168,10 @@ SHAS
   it "runs a clone command with default git options" do
     @resource.user "deployNinja"
     @resource.ssh_wrapper "do_it_this_way.sh"
-    expected_cmd = "git clone  git://github.com/opscode/chef.git /my/deploy/dir"
+    expected_cmd = "git clone  \"git://github.com/opscode/chef.git\" \"/my/deploy/dir\""
     @provider.should_receive(:shell_out!).with(expected_cmd, :user => "deployNinja",
-                                                :environment =>{"GIT_SSH"=>"do_it_this_way.sh"}, :log_level => :info, :log_tag => "git[web2.0 app]", :live_stream => STDOUT)
+                                                :environment =>{"GIT_SSH"=>"do_it_this_way.sh"},
+                                                :log_tag => "git[web2.0 app]" )
 
     @provider.clone
   end
@@ -169,36 +180,41 @@ SHAS
     @resource.user "deployNinja"
     @resource.destination "/Application Support/with/space"
     @resource.ssh_wrapper "do_it_this_way.sh"
-    expected_cmd = "git clone  git://github.com/opscode/chef.git /Application\\ Support/with/space"
+    expected_cmd = "git clone  \"git://github.com/opscode/chef.git\" \"/Application Support/with/space\""
     @provider.should_receive(:shell_out!).with(expected_cmd, :user => "deployNinja",
-                                                :environment =>{"GIT_SSH"=>"do_it_this_way.sh"}, :log_level => :info, :log_tag => "git[web2.0 app]", :live_stream => STDOUT)
+                                                :environment =>{"GIT_SSH"=>"do_it_this_way.sh"},
+                                                :log_tag => "git[web2.0 app]")
     @provider.clone
   end
 
   it "compiles a clone command using --depth for shallow cloning" do
     @resource.depth 5
-    expected_cmd = 'git clone --depth 5 git://github.com/opscode/chef.git /my/deploy/dir'
-    @provider.should_receive(:shell_out!).with(expected_cmd, {:log_level => :info, :log_tag => "git[web2.0 app]", :live_stream => STDOUT})
+    expected_cmd = "git clone --depth 5 \"git://github.com/opscode/chef.git\" \"/my/deploy/dir\""
+    @provider.should_receive(:shell_out!).with(expected_cmd, :log_tag => "git[web2.0 app]")
     @provider.clone
   end
 
   it "compiles a clone command with a remote other than ``origin''" do
     @resource.remote "opscode"
-    expected_cmd = 'git clone -o opscode git://github.com/opscode/chef.git /my/deploy/dir'
-    @provider.should_receive(:shell_out!).with(expected_cmd, {:log_level => :info, :log_tag => "git[web2.0 app]", :live_stream => STDOUT})
+    expected_cmd = "git clone -o opscode \"git://github.com/opscode/chef.git\" \"/my/deploy/dir\""
+    @provider.should_receive(:shell_out!).with(expected_cmd, :log_tag => "git[web2.0 app]")
     @provider.clone
   end
 
   it "runs a checkout command with default options" do
     expected_cmd = 'git checkout -b deploy d35af14d41ae22b19da05d7d03a0bafc321b244c'
-    @provider.should_receive(:shell_out!).with(expected_cmd, :cwd => "/my/deploy/dir", :log_level => :debug, :log_tag => "git[web2.0 app]")
+    @provider.should_receive(:shell_out!).with(expected_cmd, :cwd => "/my/deploy/dir",
+                                                             :log_tag => "git[web2.0 app]")
     @provider.checkout
   end
 
   it "runs an enable_submodule command" do
     @resource.enable_submodules true
+    expected_cmd = "git submodule sync"
+    @provider.should_receive(:shell_out!).with(expected_cmd, :cwd => "/my/deploy/dir",
+                                                             :log_tag => "git[web2.0 app]")
     expected_cmd = "git submodule update --init --recursive"
-    @provider.should_receive(:shell_out!).with(expected_cmd, :cwd => "/my/deploy/dir", :log_level => :info, :log_tag => "git[web2.0 app]", :live_stream => STDOUT)
+    @provider.should_receive(:shell_out!).with(expected_cmd, :cwd => "/my/deploy/dir", :log_tag => "git[web2.0 app]")
     @provider.enable_submodules
   end
 
@@ -208,37 +224,150 @@ SHAS
   end
 
   it "runs a sync command with default options" do
+    @provider.should_receive(:setup_remote_tracking_branches).with(@resource.remote, @resource.repository)
     expected_cmd = "git fetch origin && git fetch origin --tags && git reset --hard d35af14d41ae22b19da05d7d03a0bafc321b244c"
-    @provider.should_receive(:shell_out!).with(expected_cmd, :cwd=> "/my/deploy/dir", :log_level => :debug, :log_tag => "git[web2.0 app]")
+    @provider.should_receive(:shell_out!).with(expected_cmd, :cwd=> "/my/deploy/dir", :log_tag => "git[web2.0 app]")
     @provider.fetch_updates
   end
 
   it "runs a sync command with the user and group specified in the resource" do
     @resource.user("whois")
     @resource.group("thisis")
+    @provider.should_receive(:setup_remote_tracking_branches).with(@resource.remote, @resource.repository)
     expected_cmd = "git fetch origin && git fetch origin --tags && git reset --hard d35af14d41ae22b19da05d7d03a0bafc321b244c"
     @provider.should_receive(:shell_out!).with(expected_cmd, :cwd => "/my/deploy/dir",
-                                                :user => "whois", :group => "thisis", :log_level => :debug, :log_tag => "git[web2.0 app]")
+                                                :user => "whois", :group => "thisis", :log_tag => "git[web2.0 app]")
+    @provider.fetch_updates
+  end
+
+  it "configures remote tracking branches when remote is ``origin''" do
+    @resource.remote "origin"
+    @provider.should_receive(:setup_remote_tracking_branches).with(@resource.remote, @resource.repository)
+    fetch_command = "git fetch origin && git fetch origin --tags && git reset --hard d35af14d41ae22b19da05d7d03a0bafc321b244c"
+    @provider.should_receive(:shell_out!).with(fetch_command, :cwd => "/my/deploy/dir", :log_tag => "git[web2.0 app]")
     @provider.fetch_updates
   end
 
   it "configures remote tracking branches when remote is not ``origin''" do
     @resource.remote "opscode"
-    conf_tracking_branches =  "git config remote.opscode.url git://github.com/opscode/chef.git && " +
-                              "git config remote.opscode.fetch +refs/heads/*:refs/remotes/opscode/*"
-    @provider.should_receive(:shell_out!).with(conf_tracking_branches, :cwd => "/my/deploy/dir", :log_tag => "git[web2.0 app]", :log_level => :debug)
+    @provider.should_receive(:setup_remote_tracking_branches).with(@resource.remote, @resource.repository)
     fetch_command = "git fetch opscode && git fetch opscode --tags && git reset --hard d35af14d41ae22b19da05d7d03a0bafc321b244c"
-    @provider.should_receive(:shell_out!).with(fetch_command, :cwd => "/my/deploy/dir", :log_level => :debug, :log_tag => "git[web2.0 app]")
+    @provider.should_receive(:shell_out!).with(fetch_command, :cwd => "/my/deploy/dir", :log_tag => "git[web2.0 app]")
     @provider.fetch_updates
   end
 
+  context "configuring remote tracking branches" do
+
+    it "checks if a remote with this name already exists" do
+      command_response = double('shell_out')
+      command_response.stub(:exitstatus) { 1 }
+      expected_command = "git config --get remote.#{@resource.remote}.url"
+      @provider.should_receive(:shell_out!).with(expected_command,
+                                                 :cwd => "/my/deploy/dir",
+                                                 :log_tag => "git[web2.0 app]",
+                                                 :returns => [0,1,2]).and_return(command_response)
+      add_remote_command = "git remote add #{@resource.remote} #{@resource.repository}"
+      @provider.should_receive(:shell_out!).with(add_remote_command,
+                                                 :cwd => "/my/deploy/dir",
+                                                 :log_tag => "git[web2.0 app]")
+      @provider.setup_remote_tracking_branches(@resource.remote, @resource.repository)
+    end
+
+    it "runs the config with the user and group specified in the resource" do
+      @resource.user("whois")
+      @resource.group("thisis")
+      command_response = double('shell_out')
+      command_response.stub(:exitstatus) { 1 }
+      expected_command = "git config --get remote.#{@resource.remote}.url"
+      @provider.should_receive(:shell_out!).with(expected_command,
+                                                 :cwd => "/my/deploy/dir",
+                                                 :log_tag => "git[web2.0 app]",
+                                                 :user => "whois",
+                                                 :group => "thisis",
+                                                 :returns => [0,1,2]).and_return(command_response)
+      add_remote_command = "git remote add #{@resource.remote} #{@resource.repository}"
+      @provider.should_receive(:shell_out!).with(add_remote_command,
+                                                 :cwd => "/my/deploy/dir",
+                                                 :log_tag => "git[web2.0 app]",
+                                                 :user => "whois",
+                                                 :group => "thisis")
+      @provider.setup_remote_tracking_branches(@resource.remote, @resource.repository)
+    end
+
+    describe "when a remote with a given name hasn't been configured yet" do
+      it "adds a new remote " do
+        command_response = double('shell_out')
+        command_response.stub(:exitstatus) { 1 }
+        check_remote_command = "git config --get remote.#{@resource.remote}.url"
+        @provider.should_receive(:shell_out!).with(check_remote_command,
+                                                   :cwd => "/my/deploy/dir",
+                                                   :log_tag => "git[web2.0 app]",
+                                                   :returns => [0,1,2]).and_return(command_response)
+        expected_command = "git remote add #{@resource.remote} #{@resource.repository}"
+        @provider.should_receive(:shell_out!).with(expected_command,
+                                                   :cwd => "/my/deploy/dir",
+                                                   :log_tag => "git[web2.0 app]")
+        @provider.setup_remote_tracking_branches(@resource.remote, @resource.repository)
+      end
+    end
+
+    describe "when a remote with a given name has already been configured" do
+      it "updates remote url when the url is different" do
+        command_response = double('shell_out')
+        command_response.stub(:exitstatus) { 0 }
+        command_response.stub(:stdout) { "some_other_url" }
+        check_remote_command = "git config --get remote.#{@resource.remote}.url"
+        @provider.should_receive(:shell_out!).with(check_remote_command,
+                                                   :cwd => "/my/deploy/dir",
+                                                   :log_tag => "git[web2.0 app]",
+                                                   :returns => [0,1,2]).and_return(command_response)
+        expected_command = "git config --replace-all remote.#{@resource.remote}.url #{@resource.repository}"
+        @provider.should_receive(:shell_out!).with(expected_command,
+                                                   :cwd => "/my/deploy/dir",
+                                                   :log_tag => "git[web2.0 app]")
+        @provider.setup_remote_tracking_branches(@resource.remote, @resource.repository)
+      end
+
+      it "doesn't update remote url when the url is the same" do
+        command_response = double('shell_out')
+        command_response.stub(:exitstatus) { 0 }
+        command_response.stub(:stdout) { @resource.repository }
+        check_remote_command = "git config --get remote.#{@resource.remote}.url"
+        @provider.should_receive(:shell_out!).with(check_remote_command,
+                                                   :cwd => "/my/deploy/dir",
+                                                   :log_tag => "git[web2.0 app]",
+                                                   :returns => [0,1,2]).and_return(command_response)
+        unexpected_command = "git config --replace-all remote.#{@resource.remote}.url #{@resource.repository}"
+        @provider.should_not_receive(:shell_out!).with(unexpected_command,
+                                                       :cwd => "/my/deploy/dir",
+                                                       :log_tag => "git[web2.0 app]")
+        @provider.setup_remote_tracking_branches(@resource.remote, @resource.repository)
+      end
+
+      it "resets remote url when it has multiple values" do
+        command_response = double('shell_out')
+        command_response.stub(:exitstatus) { 2 }
+        check_remote_command = "git config --get remote.#{@resource.remote}.url"
+        @provider.should_receive(:shell_out!).with(check_remote_command,
+                                                   :cwd => "/my/deploy/dir",
+                                                   :log_tag => "git[web2.0 app]",
+                                                   :returns => [0,1,2]).and_return(command_response)
+        expected_command = "git config --replace-all remote.#{@resource.remote}.url #{@resource.repository}"
+        @provider.should_receive(:shell_out!).with(expected_command,
+                                                   :cwd => "/my/deploy/dir",
+                                                   :log_tag => "git[web2.0 app]")
+        @provider.setup_remote_tracking_branches(@resource.remote, @resource.repository)
+      end
+    end
+  end
+
   it "raises an error if the git clone command would fail because the enclosing directory doesn't exist" do
     @provider.stub!(:shell_out!)
     lambda {@provider.run_action(:sync)}.should raise_error(Chef::Exceptions::MissingParentDirectory)
   end
 
   it "does a checkout by cloning the repo and then enabling submodules" do
-    # will be invoked in load_current_resource 
+    # will be invoked in load_current_resource
     ::File.stub!(:exist?).with("/my/deploy/dir/.git").and_return(false)
 
     ::File.stub!(:exist?).with("/my/deploy/dir").and_return(true)
@@ -263,12 +392,13 @@ SHAS
     @provider.should_receive(:clone)
     @provider.should_receive(:checkout)
     @provider.should_receive(:enable_submodules)
+    @provider.should_receive(:add_remotes)
     @provider.run_action(:checkout)
    # @resource.should be_updated
   end
 
   it "should not checkout if the destination exists or is a non empty directory" do
-    # will be invoked in load_current_resource 
+    # will be invoked in load_current_resource
     ::File.stub!(:exist?).with("/my/deploy/dir/.git").and_return(false)
 
     ::File.stub!(:exist?).with("/my/deploy/dir").and_return(true)
@@ -277,6 +407,7 @@ SHAS
     @provider.should_not_receive(:clone)
     @provider.should_not_receive(:checkout)
     @provider.should_not_receive(:enable_submodules)
+    @provider.should_not_receive(:add_remotes)
     @provider.run_action(:checkout)
     @resource.should_not be_updated
   end
@@ -286,6 +417,7 @@ SHAS
     ::File.stub!(:directory?).with("/my/deploy").and_return(true)
     @provider.should_receive(:find_current_revision).exactly(2).and_return('d35af14d41ae22b19da05d7d03a0bafc321b244c')
     @provider.should_not_receive(:fetch_updates)
+    @provider.should_receive(:add_remotes)
     @provider.run_action(:sync)
     @resource.should_not be_updated
   end
@@ -298,6 +430,7 @@ SHAS
     @provider.stub!(:target_revision).and_return('28af684d8460ba4793eda3e7ac238c864a5d029a')
     @provider.should_receive(:fetch_updates)
     @provider.should_receive(:enable_submodules)
+    @provider.should_receive(:add_remotes)
     @provider.run_action(:sync)
    # @resource.should be_updated
   end
@@ -308,6 +441,7 @@ SHAS
     @provider.stub!(:find_current_revision).and_return('d35af14d41ae22b19da05d7d03a0bafc321b244c')
     @provider.stub!(:target_revision).and_return('d35af14d41ae22b19da05d7d03a0bafc321b244c')
     @provider.should_not_receive(:fetch_updates)
+    @provider.should_receive(:add_remotes)
     @provider.run_action(:sync)
     @resource.should_not be_updated
   end
@@ -339,4 +473,66 @@ SHAS
     @resource.should be_updated
   end
 
+  describe "calling add_remotes" do
+    it "adds a new remote for each entry in additional remotes hash" do
+      @resource.additional_remotes({:opscode => "opscode_repo_url",
+        :another_repo => "some_other_repo_url"})
+      STDOUT.stub(:tty?).and_return(false)
+      command_response = double('shell_out')
+      command_response.stub(:exitstatus) { 0 }
+      @resource.additional_remotes.each_pair do |remote_name, remote_url|
+        @provider.should_receive(:setup_remote_tracking_branches).with(remote_name, remote_url)
+      end
+      @provider.add_remotes
+    end
+  end
+
+  describe "calling multiple_remotes?" do
+    before(:each) do
+      @command_response = double('shell_out')
+    end
+
+    describe "when check remote command returns with status 2" do
+      it "returns true" do
+        @command_response.stub(:exitstatus) { 2 }
+        @provider.multiple_remotes?(@command_response).should be_true
+      end
+    end
+
+    describe "when check remote command returns with status 0" do
+      it "returns false" do
+        @command_response.stub(:exitstatus) { 0 }
+        @provider.multiple_remotes?(@command_response).should be_false
+      end
+    end
+
+    describe "when check remote command returns with status 0" do
+      it "returns false" do
+        @command_response.stub(:exitstatus) { 1 }
+        @provider.multiple_remotes?(@command_response).should be_false
+      end
+    end
+  end
+
+  describe "calling remote_matches?" do
+    before(:each) do
+      @command_response = double('shell_out')
+    end
+
+    describe "when output of the check remote command matches the repository url" do
+      it "returns true" do
+        @command_response.stub(:exitstatus) { 0 }
+        @command_response.stub(:stdout) { @resource.repository }
+        @provider.remote_matches?(@resource.repository, @command_response).should be_true
+      end
+    end
+
+    describe "when output of the check remote command doesn't match the repository url" do
+      it "returns false" do
+        @command_response.stub(:exitstatus) { 0 }
+        @command_response.stub(:stdout) { @resource.repository + "test" }
+        @provider.remote_matches?(@resource.repository, @command_response).should be_false
+      end
+    end
+  end
 end

data/spec/unit/provider/group/dscl_spec.rb

@@ -265,7 +265,6 @@ describe Chef::Provider::Group::Dscl do
     it "should manage the group_name if it changed and the new resources group_name is not null" do
       @current_resource.group_name("oldval")
       @new_resource.group_name("newname")
-      @provider.should_receive(:set_members).and_return(true)
       @provider.should_receive(:safe_dscl).with("create /Groups/newname")
       @provider.should_receive(:safe_dscl).with("create /Groups/newname Password '*'")
       @provider.manage_group
@@ -293,38 +292,3 @@ describe Chef::Provider::Group::Dscl do
     end
   end
 end
-
-describe 'Test DSCL loading' do
-  before do
-    @node = Chef::Node.new
-    @events = Chef::EventDispatch::Dispatcher.new
-    @run_context = Chef::RunContext.new(@node, {}, @events)
-    @new_resource = Chef::Resource::Group.new("aj")
-    @provider = Chef::Provider::Group::Dscl.new(@new_resource, @run_context)
-    @output = <<-EOF
-AppleMetaNodeLocation: /Local/Default
-Comment:
- Test Group
-GeneratedUID: AAAAAAAA-AAAA-AAAA-AAAA-AAAAAAAAAAAA
-NestedGroups: AAAAAAAA-AAAA-AAAA-AAAA-AAAAAAAAAAAB
-Password: *
-PrimaryGroupID: 999
-RealName:
- TestGroup
-RecordName: com.apple.aj
-RecordType: dsRecTypeStandard:Groups
-GroupMembership: waka bar
-EOF
-    @provider.stub(:safe_dscl).with("read /Groups/aj").and_return(@output)
-    @current_resource = @provider.load_current_resource
-  end
-
-  it 'should parse gid properly' do
-    File.stub(:exists?).and_return(true)
-    @current_resource.gid.should eq("999")
-  end
-  it 'should parse members properly' do
-    File.stub(:exists?).and_return(true)
-    @current_resource.members.should eq(['waka', 'bar'])
-  end
-end

data/spec/unit/provider/group/gpasswd_spec.rb

@@ -76,7 +76,8 @@ describe Chef::Provider::Group::Gpasswd, "modify_group_members" do
         @new_resource.members([])
       end
 
-      it "does not modify group membership" do
+      it "logs a message and does not modify group membership" do
+        Chef::Log.should_receive(:debug).with("group[wheel] not changing group members, the group has no members to add")
         @provider.should_not_receive(:shell_out!)
         @provider.modify_group_members
       end
@@ -84,7 +85,7 @@ describe Chef::Provider::Group::Gpasswd, "modify_group_members" do
 
     describe "when the resource specifies group members" do
       it "should log an appropriate debug message" do
-        Chef::Log.should_receive(:debug).with("group[wheel] setting group members to: lobster, rage, fist")
+        Chef::Log.should_receive(:debug).with("group[wheel] setting group members to lobster, rage, fist")
         @provider.stub!(:shell_out!)
         @provider.modify_group_members
       end
@@ -94,20 +95,12 @@ describe Chef::Provider::Group::Gpasswd, "modify_group_members" do
         @provider.modify_group_members
       end
 
-      describe "when no user exists in the system" do
-        before do
-          current_resource = @new_resource.dup
-          current_resource.members([ ])
-          @provider.current_resource = current_resource
-        end
-
-        it "should run gpasswd individually for each user when the append option is set" do
-          @new_resource.append(true)
-          @provider.should_receive(:shell_out!).with("gpasswd -a lobster wheel")
-          @provider.should_receive(:shell_out!).with("gpasswd -a rage wheel")
-          @provider.should_receive(:shell_out!).with("gpasswd -a fist wheel")
-          @provider.modify_group_members
-        end
+      it "should run gpasswd individually for each user when the append option is set" do
+        @new_resource.append(true)
+        @provider.should_receive(:shell_out!).with("gpasswd -a lobster wheel")
+        @provider.should_receive(:shell_out!).with("gpasswd -a rage wheel")
+        @provider.should_receive(:shell_out!).with("gpasswd -a fist wheel")
+        @provider.modify_group_members
       end
 
     end