puppet 0.25.5 → 2.6.0

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

@@ -0,0 +1,97 @@
+#!/usr/bin/env ruby
+#
+# Unit testing for the AIX System Resource Controller (src) provider
+#
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+provider_class = Puppet::Type.type(:service).provider(:src)
+
+describe provider_class do
+
+  before :each do
+    @resource = stub 'resource'
+    @resource.stubs(:[]).returns(nil)
+    @resource.stubs(:[]).with(:name).returns "myservice"
+
+    @provider = provider_class.new
+    @provider.resource = @resource
+
+    @provider.stubs(:command).with(:stopsrc).returns "/usr/bin/stopsrc"
+    @provider.stubs(:command).with(:startsrc).returns "/usr/bin/startsrc"
+    @provider.stubs(:command).with(:lssrc).returns "/usr/bin/lssrc"
+    @provider.stubs(:command).with(:refresh).returns "/usr/bin/refresh"
+
+    @provider.stubs(:stopsrc)
+    @provider.stubs(:startsrc)
+    @provider.stubs(:lssrc)
+    @provider.stubs(:refresh)
+  end
+
+  [:start, :stop, :status, :restart].each do |method|
+    it "should have a #{method} method" do
+      @provider.should respond_to(method)
+    end
+  end
+
+  it "should execute the startsrc command" do
+    @provider.expects(:execute).with(['/usr/bin/startsrc', '-s', "myservice"], {:squelch => true, :failonfail => true})
+    @provider.start
+  end
+
+  it "should execute the stopsrc command" do
+    @provider.expects(:execute).with(['/usr/bin/stopsrc', '-s', "myservice"], {:squelch => true, :failonfail => true})
+    @provider.stop
+  end
+
+  it "should execute status and return running if the subsystem is active" do
+    sample_output = <<_EOF_
+Subsystem         Group            PID          Status
+myservice         tcpip            1234         active
+_EOF_
+
+    @provider.expects(:execute).with(['/usr/bin/lssrc', '-s', "myservice"]).returns sample_output
+    @provider.status.should == :running
+  end
+
+  it "should execute status and return stopped if the subsystem is inoperative" do
+    sample_output = <<_EOF_
+Subsystem         Group            PID          Status
+myservice         tcpip                         inoperative
+_EOF_
+
+    @provider.expects(:execute).with(['/usr/bin/lssrc', '-s', "myservice"]).returns sample_output
+    @provider.status.should == :stopped
+  end
+
+  it "should execute status and return nil if the status is not known" do
+    sample_output = <<_EOF_
+Subsystem         Group            PID          Status
+myservice         tcpip                         randomdata
+_EOF_
+
+    @provider.expects(:execute).with(['/usr/bin/lssrc', '-s', "myservice"]).returns sample_output
+    @provider.status.should == nil
+  end
+
+  it "should execute restart which runs refresh" do
+    sample_output = <<_EOF_
+#subsysname:synonym:cmdargs:path:uid:auditid:standin:standout:standerr:action:multi:contact:svrkey:svrmtype:priority:signorm:sigforce:display:waittime:grpname:
+myservice:::/usr/sbin/inetd:0:0:/dev/console:/dev/console:/dev/console:-O:-Q:-K:0:0:20:0:0:-d:20:tcpip:
+_EOF_
+    @provider.expects(:execute).with(['/usr/bin/lssrc', '-Ss', "myservice"]).returns sample_output
+    @provider.expects(:execute).with(['/usr/bin/refresh', '-s', "myservice"])
+    @provider.restart
+  end
+
+  it "should execute restart which runs stopsrc then startsrc" do
+    sample_output =  <<_EOF_
+#subsysname:synonym:cmdargs:path:uid:auditid:standin:standout:standerr:action:multi:contact:svrkey:svrmtype:priority:signorm:sigforce:display:waittime:grpname:
+myservice::--no-daemonize:/usr/sbin/puppetd:0:0:/dev/null:/var/log/puppet.log:/var/log/puppet.log:-O:-Q:-S:0:0:20:15:9:-d:20::"
+_EOF_
+    @provider.expects(:execute).with(['/usr/bin/lssrc', '-Ss', "myservice"]).returns sample_output
+    @provider.expects(:execute).with(['/usr/bin/stopsrc', '-s', "myservice"], {:squelch => true, :failonfail => true})
+    @provider.expects(:execute).with(['/usr/bin/startsrc', '-s', "myservice"], {:squelch => true, :failonfail => true})
+    @provider.restart
+  end
+end

data/spec/unit/provider/ssh_authorized_key/parsed_spec.rb

@@ -0,0 +1,228 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+require 'puppet_spec/files'
+require 'puppettest'
+require 'puppettest/support/utils'
+require 'puppettest/fileparsing'
+
+provider_class = Puppet::Type.type(:ssh_authorized_key).provider(:parsed)
+
+describe provider_class do
+  include PuppetSpec::Files
+  include PuppetTest
+  include PuppetTest::FileParsing
+
+  before :each do
+    @sshauthkey_class = Puppet::Type.type(:ssh_authorized_key)
+    @provider = @sshauthkey_class.provider(:parsed)
+    @keyfile = File.join(Dir.tmpdir, 'authorized_keys')
+    @provider.any_instance.stubs(:target).returns @keyfile
+    @user = 'random_bob'
+    Puppet::Util.stubs(:uid).with(@user).returns 12345
+  end
+
+  after :each do
+    @provider.initvars
+  end
+
+  def mkkey(args)
+    fakeresource = fakeresource(:ssh_authorized_key, args[:name])
+    fakeresource.stubs(:should).with(:user).returns @user
+    fakeresource.stubs(:should).with(:target).returns @keyfile
+
+    key = @provider.new(fakeresource)
+    args.each do |p,v|
+      key.send(p.to_s + "=", v)
+    end
+
+    key
+  end
+
+  def genkey(key)
+    @provider.stubs(:filetype).returns(Puppet::Util::FileType::FileTypeRam)
+    File.stubs(:chown)
+    File.stubs(:chmod)
+    Puppet::Util::SUIDManager.stubs(:asuser).yields
+    key.flush
+    @provider.target_object(@keyfile).read
+  end
+
+  PuppetTest.fakedata("data/providers/ssh_authorized_key/parsed").each { |file|
+    it "should be able to parse example data in #{file}" do
+      fakedataparse(file)
+    end
+  }
+
+  it "should be able to generate a basic authorized_keys file" do
+
+    key = mkkey(
+      {
+        :name => "Just Testing",
+        :key => "AAAAfsfddsjldjgksdflgkjsfdlgkj",
+        :type => "ssh-dss",
+        :ensure => :present,
+
+        :options => [:absent]
+    })
+
+    genkey(key).should == "ssh-dss AAAAfsfddsjldjgksdflgkjsfdlgkj Just Testing\n"
+  end
+
+  it "should be able to generate a authorized_keys file with options" do
+
+    key = mkkey(
+      {
+        :name => "root@localhost",
+        :key => "AAAAfsfddsjldjgksdflgkjsfdlgkj",
+        :type => "ssh-rsa",
+        :ensure => :present,
+
+        :options => ['from="192.168.1.1"', "no-pty", "no-X11-forwarding"]
+    })
+
+    genkey(key).should == "from=\"192.168.1.1\",no-pty,no-X11-forwarding ssh-rsa AAAAfsfddsjldjgksdflgkjsfdlgkj root@localhost\n"
+  end
+
+  it "should be able to parse options containing commas via its parse_options method" do
+    options = %w{from="host1.reductlivelabs.com,host.reductivelabs.com" command="/usr/local/bin/run" ssh-pty}
+    optionstr = options.join(", ")
+
+    @provider.parse_options(optionstr).should == options
+  end
+
+  it "should use '' as name for entries that lack a comment" do
+    line = "ssh-rsa AAAAB3NzaC1yc2EAAAABIwAAAQEAut8aOSxenjOqF527dlsdHWV4MNoAsX14l9M297+SQXaQ5Z3BedIxZaoQthkDALlV/25A1COELrg9J2MqJNQc8Xe9XQOIkBQWWinUlD/BXwoOTWEy8C8zSZPHZ3getMMNhGTBO+q/O+qiJx3y5cA4MTbw2zSxukfWC87qWwcZ64UUlegIM056vPsdZWFclS9hsROVEa57YUMrehQ1EGxT4Z5j6zIopufGFiAPjZigq/vqgcAqhAKP6yu4/gwO6S9tatBeEjZ8fafvj1pmvvIplZeMr96gHE7xS3pEEQqnB3nd4RY7AF6j9kFixnsytAUO7STPh/M3pLiVQBN89TvWPQ=="
+
+    @provider.parse(line)[0][:name].should == ""
+  end
+end
+
+describe provider_class do
+  before :each do
+    @resource = stub("resource", :name => "foo")
+    @resource.stubs(:[]).returns "foo"
+
+    @provider = provider_class.new(@resource)
+    provider_class.stubs(:filetype).returns(Puppet::Util::FileType::FileTypeRam)
+    Puppet::Util::SUIDManager.stubs(:asuser).yields
+  end
+
+  describe "when flushing" do
+    before :each do
+      # Stub file and directory operations
+      Dir.stubs(:mkdir)
+      File.stubs(:chmod)
+      File.stubs(:chown)
+    end
+
+    describe "and both a user and a target have been specified" do
+      before :each do
+        Puppet::Util.stubs(:uid).with("random_bob").returns 12345
+        @resource.stubs(:should).with(:user).returns "random_bob"
+        target = "/tmp/.ssh_dir/place_to_put_authorized_keys"
+        @resource.stubs(:should).with(:target).returns target
+      end
+
+      it "should create the directory" do
+        File.stubs(:exist?).with("/tmp/.ssh_dir").returns false
+        Dir.expects(:mkdir).with("/tmp/.ssh_dir", 0700)
+        @provider.flush
+      end
+
+      it "should chown the directory to the user" do
+        uid = Puppet::Util.uid("random_bob")
+        File.expects(:chown).with(uid, nil, "/tmp/.ssh_dir")
+        @provider.flush
+      end
+
+      it "should chown the key file to the user" do
+        uid = Puppet::Util.uid("random_bob")
+        File.expects(:chown).with(uid, nil, "/tmp/.ssh_dir/place_to_put_authorized_keys")
+        @provider.flush
+      end
+
+      it "should chmod the key file to 0600" do
+        File.expects(:chmod).with(0600, "/tmp/.ssh_dir/place_to_put_authorized_keys")
+        @provider.flush
+      end
+    end
+
+    describe "and a user has been specified with no target" do
+      before :each do
+        @resource.stubs(:should).with(:user).returns "nobody"
+        @resource.stubs(:should).with(:target).returns nil
+        #
+        # I'd like to use random_bob here and something like
+        #
+        #    File.stubs(:expand_path).with("~random_bob/.ssh").returns "/users/r/random_bob/.ssh"
+        #
+        # but mocha objects strenuously to stubbing File.expand_path
+        # so I'm left with using nobody.
+        @dir = File.expand_path("~nobody/.ssh")
+      end
+
+      it "should create the directory if it doesn't exist" do
+        File.stubs(:exist?).with(@dir).returns false
+        Dir.expects(:mkdir).with(@dir,0700)
+        @provider.flush
+      end
+
+      it "should not create or chown the directory if it already exist" do
+        File.stubs(:exist?).with(@dir).returns false
+        Dir.expects(:mkdir).never
+        @provider.flush
+      end
+
+      it "should chown the directory to the user if it creates it" do
+        File.stubs(:exist?).with(@dir).returns false
+        Dir.stubs(:mkdir).with(@dir,0700)
+        uid = Puppet::Util.uid("nobody")
+        File.expects(:chown).with(uid, nil, @dir)
+        @provider.flush
+      end
+
+      it "should not create or chown the directory if it already exist" do
+        File.stubs(:exist?).with(@dir).returns false
+        Dir.expects(:mkdir).never
+        File.expects(:chown).never
+        @provider.flush
+      end
+
+      it "should chown the key file to the user" do
+        uid = Puppet::Util.uid("nobody")
+        File.expects(:chown).with(uid, nil, File.expand_path("~nobody/.ssh/authorized_keys"))
+        @provider.flush
+      end
+
+      it "should chmod the key file to 0600" do
+        File.expects(:chmod).with(0600, File.expand_path("~nobody/.ssh/authorized_keys"))
+        @provider.flush
+      end
+    end
+
+    describe "and a target has been specified with no user" do
+      before :each do
+        @resource.stubs(:should).with(:user).returns nil
+        @resource.stubs(:should).with(:target).returns("/tmp/.ssh_dir/place_to_put_authorized_keys")
+      end
+
+      it "should raise an error" do
+        proc { @provider.flush }.should raise_error
+      end
+    end
+
+    describe "and a invalid user has been specified with no target" do
+      before :each do
+        @resource.stubs(:should).with(:user).returns "thisusershouldnotexist"
+        @resource.stubs(:should).with(:target).returns nil
+      end
+
+      it "should catch an exception and raise a Puppet error" do
+        lambda { @provider.flush }.should raise_error(Puppet::Error)
+      end
+    end
+
+  end
+end

data/spec/unit/provider/sshkey/parsed_spec.rb

@@ -0,0 +1,38 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+provider_class = Puppet::Type.type(:sshkey).provider(:parsed)
+
+describe provider_class do
+  before do
+    @sshkey_class = Puppet::Type.type(:sshkey)
+    @provider_class = @sshkey_class.provider(:parsed)
+    @key = 'AAAAB3NzaC1yc2EAAAABIwAAAQEAzwHhxXvIrtfIwrudFqc8yQcIfMudrgpnuh1F3AV6d2BrLgu/yQE7W5UyJMUjfj427sQudRwKW45O0Jsnr33F4mUw+GIMlAAmp9g24/OcrTiB8ZUKIjoPy/cO4coxGi8/NECtRzpD/ZUPFh6OEpyOwJPMb7/EC2Az6Otw4StHdXUYw22zHazBcPFnv6zCgPx1hA7QlQDWTu4YcL0WmTYQCtMUb3FUqrcFtzGDD0ytosgwSd+JyN5vj5UwIABjnNOHPZ62EY1OFixnfqX/+dUwrFSs5tPgBF/KkC6R7tmbUfnBON6RrGEmu+ajOTOLy23qUZB4CQ53V7nyAWhzqSK+hw=='
+  end
+
+  it "should parse the name from the first field" do
+    @provider_class.parse_line('test ssh-rsa '+@key)[:name].should == "test"
+  end
+
+  it "should parse the first component of the first field as the name" do
+    @provider_class.parse_line('test,alias ssh-rsa '+@key)[:name].should == "test"
+  end
+
+  it "should parse host_aliases from the remaining components of the first field" do
+    @provider_class.parse_line('test,alias ssh-rsa '+@key)[:host_aliases].should == ["alias"]
+  end
+
+  it "should parse multiple host_aliases" do
+    @provider_class.parse_line('test,alias1,alias2,alias3 ssh-rsa '+@key)[:host_aliases].should == ["alias1","alias2","alias3"]
+  end
+
+  it "should not drop an empty host_alias" do
+    @provider_class.parse_line('test,alias, ssh-rsa '+@key)[:host_aliases].should == ["alias",""]
+  end
+
+  it "should recognise when there are no host aliases" do
+    @provider_class.parse_line('test ssh-rsa '+@key)[:host_aliases].should == []
+  end
+
+end

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

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+provider_class = Puppet::Type.type(:user).provider(:hpuxuseradd)
+
+describe provider_class do
+  # left from the useradd test... I have no clue what I'm doing.
+  before do
+    @resource = stub("resource", :name => "myuser", :managehome? => nil, :should => "fakeval", :[] => "fakeval")
+    @provider = provider_class.new(@resource)
+  end
+
+  it "should add -F when modifying a user" do
+    @resource.expects(:allowdupe?).returns true
+    @provider.expects(:execute).with { |args| args.include?("-F") }
+    @provider.uid = 1000
+  end
+
+  it "should add -F when deleting a user" do
+    @provider.stubs(:exists?).returns(true)
+    @provider.expects(:execute).with { |args| args.include?("-F") }
+    @provider.delete
+  end
+end

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

@@ -0,0 +1,279 @@
+#!/usr/bin/env ruby
+#
+#  Created by Luke Kanies on 2008-3-10.
+#  Copyright (c) 2006. All rights reserved.
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+provider_class = Puppet::Type.type(:user).provider(:ldap)
+
+describe provider_class do
+  it "should have the Ldap provider class as its baseclass" do
+    provider_class.superclass.should equal(Puppet::Provider::Ldap)
+  end
+
+  it "should manage :posixAccount and :person objectclasses" do
+    provider_class.manager.objectclasses.should == [:posixAccount, :person]
+  end
+
+  it "should use 'ou=People' as its relative base" do
+    provider_class.manager.location.should == "ou=People"
+  end
+
+  it "should use :uid as its rdn" do
+    provider_class.manager.rdn.should == :uid
+  end
+
+  it "should be able to manage passwords" do
+    provider_class.should be_manages_passwords
+  end
+
+  it "should use the ldap group provider to convert group names to numbers" do
+    provider = provider_class.new(:name => "foo")
+    Puppet::Type.type(:group).provider(:ldap).expects(:name2id).with("bar").returns 10
+
+    provider.gid = 'bar'
+    provider.gid.should == 10
+  end
+
+  {:name => "uid",
+    :password => "userPassword",
+    :comment => "cn",
+    :uid => "uidNumber",
+    :gid => "gidNumber",
+    :home => "homeDirectory",
+    :shell => "loginShell"
+  }.each do |puppet, ldap|
+    it "should map :#{puppet.to_s} to '#{ldap}'" do
+      provider_class.manager.ldap_name(puppet).should == ldap
+    end
+  end
+
+  describe "when being created" do
+    before do
+      # So we don't try to actually talk to ldap
+      @connection = mock 'connection'
+      provider_class.manager.stubs(:connect).yields @connection
+    end
+
+    it "should generate the sn as the last field of the cn" do
+      resource = stub 'resource', :should => %w{whatever}
+      resource.stubs(:should).with(:comment).returns ["Luke Kanies"]
+      resource.stubs(:should).with(:ensure).returns :present
+      instance = provider_class.new(:name => "luke", :ensure => :absent)
+      instance.stubs(:resource).returns resource
+
+      @connection.expects(:add).with { |dn, attrs| attrs["sn"] == ["Kanies"] }
+
+      instance.create
+      instance.flush
+    end
+
+    describe "with no uid specified" do
+      it "should pick the first available UID after the largest existing UID" do
+        low = {:name=>["luke"], :shell=>:absent, :uid=>["600"], :home=>["/h"], :gid=>["1000"], :password=>["blah"], :comment=>["l k"]}
+        high = {:name=>["testing"], :shell=>:absent, :uid=>["640"], :home=>["/h"], :gid=>["1000"], :password=>["blah"], :comment=>["t u"]}
+        provider_class.manager.expects(:search).returns([low, high])
+
+        resource = stub 'resource', :should => %w{whatever}
+        resource.stubs(:should).with(:uid).returns nil
+        resource.stubs(:should).with(:ensure).returns :present
+        instance = provider_class.new(:name => "luke", :ensure => :absent)
+        instance.stubs(:resource).returns resource
+
+        @connection.expects(:add).with { |dn, attrs| attrs["uidNumber"] == ["641"] }
+
+        instance.create
+        instance.flush
+      end
+
+      it "should pick 501 of no users exist" do
+        provider_class.manager.expects(:search).returns nil
+
+        resource = stub 'resource', :should => %w{whatever}
+        resource.stubs(:should).with(:uid).returns nil
+        resource.stubs(:should).with(:ensure).returns :present
+        instance = provider_class.new(:name => "luke", :ensure => :absent)
+        instance.stubs(:resource).returns resource
+
+        @connection.expects(:add).with { |dn, attrs| attrs["uidNumber"] == ["501"] }
+
+        instance.create
+        instance.flush
+      end
+    end
+  end
+
+  describe "when flushing" do
+    before do
+      provider_class.stubs(:suitable?).returns true
+
+      @instance = provider_class.new(:name => "myname", :groups => %w{whatever}, :uid => "400")
+    end
+
+    it "should remove the :groups value before updating" do
+      @instance.class.manager.expects(:update).with { |name, ldap, puppet| puppet[:groups].nil? }
+
+      @instance.flush
+    end
+
+    it "should empty the property hash" do
+      @instance.class.manager.stubs(:update)
+
+      @instance.flush
+
+      @instance.uid.should == :absent
+    end
+
+    it "should empty the ldap property hash" do
+      @instance.class.manager.stubs(:update)
+
+      @instance.flush
+
+      @instance.ldap_properties[:uid].should be_nil
+    end
+  end
+
+  describe "when checking group membership" do
+    before do
+      @groups = Puppet::Type.type(:group).provider(:ldap)
+      @group_manager = @groups.manager
+      provider_class.stubs(:suitable?).returns true
+
+      @instance = provider_class.new(:name => "myname")
+    end
+
+    it "should show its group membership as the sorted list of all groups returned by an ldap query of group memberships" do
+      one = {:name => "one"}
+      two = {:name => "two"}
+      @group_manager.expects(:search).with("memberUid=myname").returns([two, one])
+
+      @instance.groups.should == "one,two"
+    end
+
+    it "should show its group membership as :absent if no matching groups are found in ldap" do
+      @group_manager.expects(:search).with("memberUid=myname").returns(nil)
+
+      @instance.groups.should == :absent
+    end
+
+    it "should cache the group value" do
+      @group_manager.expects(:search).with("memberUid=myname").once.returns nil
+
+      @instance.groups
+      @instance.groups.should == :absent
+    end
+  end
+
+  describe "when modifying group membership" do
+    before do
+      @groups = Puppet::Type.type(:group).provider(:ldap)
+      @group_manager = @groups.manager
+      provider_class.stubs(:suitable?).returns true
+
+      @one = {:name => "one", :gid => "500"}
+      @group_manager.stubs(:find).with("one").returns(@one)
+
+      @two = {:name => "one", :gid => "600"}
+      @group_manager.stubs(:find).with("two").returns(@two)
+
+      @instance = provider_class.new(:name => "myname")
+
+      @instance.stubs(:groups).returns :absent
+    end
+
+    it "should fail if the group does not exist" do
+      @group_manager.expects(:find).with("mygroup").returns nil
+
+      lambda { @instance.groups = "mygroup" }.should raise_error(Puppet::Error)
+    end
+
+    it "should only pass the attributes it cares about to the group manager" do
+      @group_manager.expects(:update).with { |name, attrs| attrs[:gid].nil? }
+
+      @instance.groups = "one"
+    end
+
+    it "should always include :ensure => :present in the current values" do
+      @group_manager.expects(:update).with { |name, is, should| is[:ensure] == :present }
+
+      @instance.groups = "one"
+    end
+
+    it "should always include :ensure => :present in the desired values" do
+      @group_manager.expects(:update).with { |name, is, should| should[:ensure] == :present }
+
+      @instance.groups = "one"
+    end
+
+    it "should always pass the group's original member list" do
+      @one[:members] = %w{yay ness}
+      @group_manager.expects(:update).with { |name, is, should| is[:members] == %w{yay ness} }
+
+      @instance.groups = "one"
+    end
+
+    it "should find the group again when resetting its member list, so it has the full member list" do
+      @group_manager.expects(:find).with("one").returns(@one)
+
+      @group_manager.stubs(:update)
+
+      @instance.groups = "one"
+    end
+
+    describe "for groups that have no members" do
+      it "should create a new members attribute with its value being the user's name" do
+        @group_manager.expects(:update).with { |name, is, should| should[:members] == %w{myname} }
+
+        @instance.groups = "one"
+      end
+    end
+
+    describe "for groups it is being removed from" do
+      it "should replace the group's member list with one missing the user's name" do
+        @one[:members] = %w{myname a}
+        @two[:members] = %w{myname b}
+
+        @group_manager.expects(:update).with { |name, is, should| name == "two" and should[:members] == %w{b} }
+
+        @instance.stubs(:groups).returns "one,two"
+        @instance.groups = "one"
+      end
+
+      it "should mark the member list as empty if there are no remaining members" do
+        @one[:members] = %w{myname}
+        @two[:members] = %w{myname b}
+
+        @group_manager.expects(:update).with { |name, is, should| name == "one" and should[:members] == :absent }
+
+        @instance.stubs(:groups).returns "one,two"
+        @instance.groups = "two"
+      end
+    end
+
+    describe "for groups that already have members" do
+      it "should replace each group's member list with a new list including the user's name" do
+        @one[:members] = %w{a b}
+        @group_manager.expects(:update).with { |name, is, should| should[:members] == %w{a b myname} }
+        @two[:members] = %w{b c}
+        @group_manager.expects(:update).with { |name, is, should| should[:members] == %w{b c myname} }
+
+        @instance.groups = "one,two"
+      end
+    end
+
+    describe "for groups of which it is a member" do
+      it "should do nothing" do
+        @one[:members] = %w{a b}
+        @group_manager.expects(:update).with { |name, is, should| should[:members] == %w{a b myname} }
+
+        @two[:members] = %w{c myname}
+        @group_manager.expects(:update).with { |name, *other| name == "two" }.never
+
+        @instance.stubs(:groups).returns "two"
+
+        @instance.groups = "one,two"
+      end
+    end
+  end
+end