← Back to branch summary

~ubuntu-branches/ubuntu/lucid/puppet/lucid-security

« back to all changes in this revision

Viewing changes to test/ral/type/resources.rb

  • Committer: Bazaar Package Importer
  • Author(s): Chuck Short
  • Date: 2009-12-23 00:48:10 UTC
  • mfrom: (1.1.10 upstream) (3.1.7 squeeze)
  • Revision ID: james.westby@ubuntu.com-20091223004810-3i4oryds922g5n59
Tags: 0.25.1-3ubuntu1
* Merge from debian testing.  Remaining changes:
  - debian/rules:
    + Don't start puppet when first installing puppet.
  - debian/puppet.conf, lib/puppet/defaults.rb:
    + Move templates to /etc/puppet
  - lib/puppet/defaults.rb:
    + Fix /var/lib/puppet/state ownership.
  - man/man8/puppet.conf.8: 
    + Fix broken URL in manpage.
  - debian/control:
    + Update maintainer accordint to spec.
    + Puppetmaster Recommends -> Suggests
    + Created puppet-testsuite as a seperate. Allow the users to run puppet's 
      testsuite.
  - tests/Rakefile: Fix rakefile so that the testsuite can acutally be ran.

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/ral/type/resources.rb
8
8
require 'puppettest'
9
9
 
10
10
class TestResources < Test::Unit::TestCase
11
 
        include PuppetTest
12
 
        
13
 
        def add_purge_lister
 
11
    include PuppetTest
 
12
 
 
13
    def add_purge_lister
14
14
        # Now define the list method
15
15
        class << @purgetype
16
16
            def instances
18
18
            end
19
19
        end
20
20
    end
21
 
    
 
21
 
22
22
    def mk_purger(managed = false)
23
23
        @purgenum ||= 0
24
24
        @purgenum += 1
29
29
        end
30
30
        obj
31
31
    end
32
 
        
33
 
        def mkpurgertype
 
32
 
 
33
    def mkpurgertype
34
34
        # Create a purgeable type
35
35
        $purgemembers = {}
36
36
        @purgetype = Puppet::Type.newtype(:purgetest) do
53
53
            Puppet::Type.rmtype(:purgetest)
54
54
        end
55
55
    end
56
 
        
57
 
        def setup
58
 
            super
59
 
            @type = Puppet::Type.type(:resources)
 
56
 
 
57
    def setup
 
58
        super
 
59
        @type = Puppet::Type.type(:resources)
60
60
    end
61
61
 
62
62
    def test_purge
63
63
        # Create a purgeable type
64
64
        mkpurgertype
65
 
        
 
65
 
66
66
        purger = nil
67
67
        assert_nothing_raised do
68
 
            purger = @type.create :name => "purgetest", :noop => true, :loglevel => :warning
 
68
            purger = @type.new :name => "purgetest", :noop => true, :loglevel => :warning
69
69
        end
70
70
        assert(purger, "did not get purger manager")
71
71
        add_purge_lister()
72
 
        
 
72
 
73
73
        assert_equal($purgemembers.values.sort, @purgetype.instances.sort)
74
 
        
 
74
 
75
75
        # and it should now succeed
76
76
        assert_nothing_raised do
77
77
            purger[:purge] = true
78
78
        end
79
79
        assert(purger.purge?, "purge boolean was not enabled")
80
 
        
 
80
 
81
81
        # Okay, now let's try doing some purging, yo
82
82
        managed = []
83
83
        unmanned = []
84
84
        3.times { managed << mk_purger(true) } # 3 managed
85
85
        3.times { unmanned << mk_purger(false) } # 3 unmanaged
86
 
        
 
86
 
87
87
        managed.each do |m|
88
88
            assert(m.managed?, "managed resource was not considered managed")
89
89
        end
90
90
        unmanned.each do |u|
91
91
            assert(! u.managed?, "unmanaged resource was considered managed")
92
92
        end
93
 
        
 
93
 
94
94
        # First make sure we get nothing back when purge is false
95
95
        genned = nil
96
96
        purger[:purge] = false
98
98
            genned = purger.generate
99
99
        end
100
100
        assert_equal([], genned, "Purged even when purge is false")
101
 
        
 
101
 
102
102
        # Now make sure we can purge
103
103
        purger[:purge] = true
104
104
        assert_nothing_raised do
110
110
            assert(res.purging, "did not mark resource for purging")
111
111
        end
112
112
        assert(! genned.empty?, "generated resource list was empty")
113
 
        
 
113
 
114
114
        # Now make sure the generate method only finds the unmanaged resources
115
115
        assert_equal(unmanned.collect { |r| r.title }.sort, genned.collect { |r| r.title },
116
116
            "Did not return correct purge list")
117
 
        
 
117
 
118
118
        # Now make sure our metaparams carried over
119
119
        genned.each do |res|
120
120
            [:noop, :loglevel].each do |param|
122
122
            end
123
123
        end
124
124
    end
125
 
    
 
125
 
126
126
    # Part of #408.
127
127
    def test_check
128
128
        # First check a non-user
129
 
        res = Puppet::Type.type(:resources).create :name => :package
 
129
        res = Puppet::Type.type(:resources).new :name => :package
130
130
        assert_nil(res[:unless_system_user], "got bad default for package")
131
 
        
132
 
        
 
131
 
 
132
 
133
133
        assert_nothing_raised {
134
134
            assert(res.check("A String"), "String failed check")
135
 
            assert(res.check(Puppet::Type.type(:file).create(:path => tempfile())), "File failed check")
136
 
            assert(res.check(Puppet::Type.type(:user).create(:name => "yayness")), "User failed check in package")
 
135
            assert(res.check(Puppet::Type.type(:file).new(:path => tempfile())), "File failed check")
 
136
            assert(res.check(Puppet::Type.type(:user).new(:name => "yayness")), "User failed check in package")
137
137
        }
138
 
        
 
138
 
139
139
        # Now create a user manager
140
 
        res = Puppet::Type.type(:resources).create :name => :user
141
 
        
 
140
        res = Puppet::Type.type(:resources).new :name => :user
 
141
 
142
142
        # Make sure the default is 500
143
143
        assert_equal(500, res[:unless_system_user], "got bad default")
144
 
        
 
144
 
145
145
        # Now make sure root fails the test
146
146
        @user = Puppet::Type.type(:user)
147
147
        assert_nothing_raised {
148
148
            assert(! res.check(@user.create(:name => "root")), "root passed check")
149
149
            assert(! res.check(@user.create(:name => "nobody")), "nobody passed check")
150
150
        }
151
 
        
 
151
 
152
152
        # Now find a user between 0 and the limit
153
153
        low = high = nil
154
154
        Etc.passwd { |entry|
163
163
                end
164
164
            end
165
165
        }
166
 
        
 
166
 
167
167
        if low
168
168
            assert(! res.check(@user.create(:name => low)), "low user %s passed check" % low)
169
169
        end
172
172
            assert(res.check(@user.create(:name => high)), "high user %s failed check" % high)
173
173
        end
174
174
    end
175
 
    
 
175
 
176
176
    # The other half of #408.
177
177
    def test_check_is_called
178
 
        res = Puppet::Type.type(:resources).create :name => :user, :purge => true
179
 
        
 
178
        res = Puppet::Type.type(:resources).new :name => :user, :purge => true
 
179
 
180
180
        list = nil
181
181
        assert_nothing_raised { list = res.generate }
182
 
        
 
182
 
183
183
        assert(! list.empty?, "did not get any users")
184
 
        
 
184
 
185
185
        bad = list.find_all { |u|
186
186
                %w{root bin nobody}.include?(u[:name]) or (cv = u.retrieve and cv[u.property(:uid)] < 500)
187
187
            }