puppet 0.25.5 → 2.6.0

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

@@ -1,140 +0,0 @@
-#!/usr/bin/env ruby
-#
-# Unit testing for the Runit service Provider
-#
-# author Brice Figureau
-#
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-provider_class = Puppet::Type.type(:service).provider(:runit)
-
-describe provider_class do
-
-    before(:each) do
-        # Create a mock resource
-        @resource = stub 'resource'
-
-        @provider = provider_class.new
-        @servicedir = "/etc/service"
-        @provider.servicedir=@servicedir
-        @daemondir = "/etc/sv"
-        @provider.class.defpath=@daemondir
-
-        # A catch all; no parameters set
-        @resource.stubs(:[]).returns(nil)
-
-        # But set name, source and path (because we won't run
-        # the thing that will fetch the resource path from the provider)
-        @resource.stubs(:[]).with(:name).returns "myservice"
-        @resource.stubs(:[]).with(:ensure).returns :enabled
-        @resource.stubs(:[]).with(:path).returns @daemondir
-        @resource.stubs(:ref).returns "Service[myservice]"
-
-        @provider.stubs(:sv)
-
-        @provider.stubs(:resource).returns @resource
-    end
-
-    it "should have a restart method" do
-        @provider.should respond_to(:restart)
-    end
-
-    it "should have a restartcmd method" do
-        @provider.should respond_to(:restartcmd)
-    end
-
-    it "should have a start method" do
-        @provider.should respond_to(:start)
-    end
-
-    it "should have a stop method" do
-        @provider.should respond_to(:stop)
-    end
-
-    it "should have an enabled? method" do
-        @provider.should respond_to(:enabled?)
-    end
-
-    it "should have an enable method" do
-        @provider.should respond_to(:enable)
-    end
-
-    it "should have a disable method" do
-        @provider.should respond_to(:disable)
-    end
-
-    describe "when starting" do
-        it "should enable the service if it is not enabled" do
-            @provider.stubs(:sv)
-
-            @provider.expects(:enabled?).returns :false
-            @provider.expects(:enable)
-
-            @provider.start
-        end
-
-        it "should execute external command 'sv start /etc/service/myservice'" do
-            @provider.stubs(:enabled?).returns :true
-            @provider.expects(:sv).with("start", "/etc/service/myservice")
-            @provider.start
-        end
-    end
-
-    describe "when stopping" do
-        it "should execute external command 'sv stop /etc/service/myservice'" do
-            @provider.expects(:sv).with("stop", "/etc/service/myservice")
-            @provider.stop
-        end
-    end
-
-    describe "when restarting" do
-        it "should call 'sv restart /etc/service/myservice'" do
-            @provider.expects(:sv).with("restart","/etc/service/myservice")
-            @provider.restart
-        end
-    end
-
-    describe "when enabling" do
-        it "should create a symlink between daemon dir and service dir" do
-            FileTest.stubs(:symlink?).returns(false)
-            File.expects(:symlink).with(File.join(@daemondir,"myservice"), File.join(@servicedir,"myservice")).returns(0)
-            @provider.enable
-        end
-    end
-
-    describe "when disabling" do
-        it "should remove the '/etc/service/myservice' symlink" do
-            FileTest.stubs(:directory?).returns(false)
-            FileTest.stubs(:symlink?).returns(true)
-            File.expects(:unlink).with(File.join(@servicedir,"myservice")).returns(0)
-            @provider.disable
-        end
-    end
-
-    describe "when checking status" do
-        it "should call the external command 'sv status /etc/sv/myservice'" do
-            @provider.expects(:sv).with('status',File.join(@daemondir,"myservice"))
-            @provider.status
-        end
-    end
-
-    describe "when checking status" do
-        it "and sv status fails, properly raise a Puppet::Error" do
-            @provider.expects(:sv).with('status',File.join(@daemondir,"myservice")).raises(Puppet::ExecutionFailure, "fail: /etc/sv/myservice: file not found")
-            lambda { @provider.status }.should raise_error(Puppet::Error, 'Could not get status for service Service[myservice]: fail: /etc/sv/myservice: file not found')
-        end
-        it "and sv status returns up, then return :running" do
-            @provider.expects(:sv).with('status',File.join(@daemondir,"myservice")).returns("run: /etc/sv/myservice: (pid 9029) 6s")
-            @provider.status.should == :running
-        end
-        it "and sv status returns not running, then return :stopped" do
-            @provider.expects(:sv).with('status',File.join(@daemondir,"myservice")).returns("fail: /etc/sv/myservice: runsv not running")
-            @provider.status.should == :stopped
-        end
-        it "and sv status returns a warning, then return :stopped" do
-            @provider.expects(:sv).with('status',File.join(@daemondir,"myservice")).returns("warning: /etc/sv/myservice: unable to open supervise/ok: file does not exist")
-            @provider.status.should == :stopped
-        end
-    end
-
- end

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

@@ -1,206 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../../spec_helper'
-
-require 'puppettest'
-require 'puppettest/support/utils'
-require 'puppettest/fileparsing'
-
-provider_class = Puppet::Type.type(:ssh_authorized_key).provider(:parsed)
-
-describe provider_class do
-    include PuppetTest
-    include PuppetTest::FileParsing
-
-    before :each do
-        @sshauthkey_class = Puppet::Type.type(:ssh_authorized_key)
-        @provider = @sshauthkey_class.provider(:parsed)
-        @keyfile = File.join(tmpdir, 'authorized_keys')
-        @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)
-        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
-            puts "Parsing %s" % file
-            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 "'s parse_options method should be able to parse options containing commas" do
-        options = %w{from="host1.reductlivelabs.com,host.puppetlabs.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)
-    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
-    end
-end

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

@@ -1,38 +0,0 @@
-#!/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.rb

@@ -1,25 +0,0 @@
-#!/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.rb

@@ -1,279 +0,0 @@
-#!/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 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([one, two])
-
-            @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